线性表的链式存储结构实验报告
实验二 链式存储线性表
实验二 链式存储线性表的基本操作一、 实验目的1. 掌握用Turbo C2.0上机调试线性表的基本方法。
2. 掌握线性表的基本操作，插入、删除、查找，以及线性表合并等运算在链接存储结构上的运算。
二、 实验内容1.typedef int ElemType;typedef struct LNode { //创建结构体数据类型LNodeElemType data; //存放数值的数据域struct LNode *next; //存放后继结点地址的指针域}LNode;2. 链表的创建：创建n 个结点，利用scanf( )函数为每个结点的数据域赋值，一次将每个结点插入链表，形成一个包含n 个元素的链表。
#define NULL 0#define OVERFLOW 0#define OK 1#define ERROR -1typedef int ElemType;typedef struct LNode { //创建LNode 数据类型ElemType data;struct LNode *next;}LNode;typedef LNode *LinkList; //定义LinkList 指针型数据类型int CreateList_L(LinkList L, int n) { //创建拥有n 个元素的线性链表//int i;struct LNode *p;L->next = NULL; //线性链表初始化，见右图for (i = n; i > 0; --i) { //循环n 次在头结点和第一个结点间插入新结点，形成长度为n 的线性链表p =(LNode*)malloc(sizeof(LNode));scanf("%d",&p->data);p->next = L ->next;L->next =p;}return 1;}data next data nextl1)2)3)int VistList_L(LinkList L) { //遍历链表L中每个结点的函数struct LNode *p;p = L->next;while (p) {printf("%d ",p->data); //访问输出p结点的数据域p = p->next; } //p指针前进一位，指向后继结点printf("\n");return OK;}}lmain(){int m;LNode l;ElemType e;printf("please input the length of the linklist that you want to build");scanf("%d",&m);printf("please give the number that you want to insert");CreateList_L(&l,m); //调用创建链表函数VistList_L(&l); //调用遍历链表结点函数}3. 链表的插入算法：向链表中某个位置上插入一个结点#define NULL 0#define OVERFLOW 0#define OK 1#define ERROR -1typedef int ElemType;typedef struct LNode { //创建LNode 数据类型ElemType data;struct LNode *next;}LNode;typedef LNode *LinkList;int CreateList_L(LinkList L, int n) { //创建包含n 个元素的链表int i;struct LNode *p;L->next = NULL;for (i = n; i > 0; --i) {p =(LNode*)malloc(sizeof(LNode));scanf("%d",&p->data);p->next = L ->next;L->next =p;}return 1;}int ListInsert_L(LinkList L, int i, ElemType e) { //向链表中第i位插入数据e struct LNode *s,*p;int j;p = ; j = 0; //p指针指向线性链表的头结点while (p && j < ) //循环查找第i-1位作为数据e的插入位置{ p = ; ++j; } //p指针向前移动if (!p || j > i-1)return ERROR;s =(LNode*)malloc(sizeof(LNode)); //见下图1）if ( s == NULL) return ERROR;s-> = e; //将插入数据e的值赋值给s结点的数据域1）s->next = ; p->next = ; //旧链断开，新链产生2）3）return OK;}1）2）3）int VistList_L(LinkList L) { //遍历链表所有结点的函数struct LNode *p;p = L->next;while (p) {printf("%d",p->data);p = p->next; }return OK;}main(){int m;LNode l;ElemType e;int i;printf("please input the length of the linklist that you want to build");scanf("%d",&m);printf("please give the number that the initial list have");CreateList_L(&l,m);VistList_L(&l);printf("please input the positon and data of the insert number i&e");scanf("%d,%d",&i,&e);ListInsert_L(&l,i,e);VistList_L(&l);}附：一元多项式的相加#include<stdio.h>#include<stdlib.h>#define LEN sizeof(node)typedef struct polynode /*用单链表存储多项式的结点结构*/{int coef; /*多项式的系数*/int exp; /*指数*/struct polynode *next; /*next是struct polynode类型中的一个成员，它又指向struct polynode类型的数据，以此建立链表*/}node;/*若定为"node,*list;"，意即node*与list同为结构指针类型*/node * create(void) /*指针函数，返回指针类型；用尾插法建立一元多项式的链表的函数*/ {node *h,*r,*s;int c,e;h=(node *)malloc(LEN); /*建立多项式的头结点，为头结点分配存储空间*/r=h; /*r指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/ printf("coef:");scanf("%d",&c); /*输入系数*/printf("exp: ");scanf("%d",&e); /*输入指针*/while(c!=0) /*输入系数为0时，表示多项式的输入结束*/{s=(node *)malloc(LEN); /*申请新结点*/s->coef=c; /*申请新结点后赋值*/s->exp=e; /*申请新结点后赋值*/r->next=s; /*做尾插，插入新结点*/r=s; /*r始终指向单链表的表尾*/printf("coef:");scanf("%d",&c);printf("exp: ");scanf("%d",&e);}r->next=NULL; /*将表的最后一个结点的next置NULL，以示表结束*/return(h);}void polyadd(node *polya, node *polyb)/*一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式polya中，并将多项式ployb删除*/{node *p,*q,*pre,*temp;int sum;p=polya->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/q=polyb->next;pre=polya; /*位置指针，指向和多项式polya*/while(p!=NULL&&q!=NULL) /*当两个多项式均未扫描结束时，执行以下操作*/{if(p->exp<q->exp) /*若p指向的多项式指数小于q指的指数*/{pre->next=p; /*将p结点加入到和多项式中*/pre=pre->next;p=p->next;}else if(p->exp==q->exp) /*若指数相等，则相应的系数相加*/{sum=p->coef+q->coef;if(sum!=0){p->coef=sum;pre->next=p;pre=pre->next;p=p->next;temp=q;q=q->next;free(temp);}else /*如果系数和为零，则删除结点p与q，并将指针指向下一个结点*/{temp=p->next;free(p);p=temp;temp=q->next;free(q);q=temp;}}else /*若p指数大于q指数*/{pre->next=q; /*p结点不动，将q结点加入到和多项式中*/pre=pre->next;q=q->next;}}if(p!=NULL) /*多项式A中还有剩余，则将剩余的结点加入到和多项式中*/ pre->next=p;else /*否则将B的结点加入到和多项式中*/pre->next=q;}void print(node * p) /*输出函数，打印出一元多项式*/{while(p->next!=NULL){p=p->next;printf(" %d*x^%d",p->coef,p->exp);}}main() /*主函数*/{node * polya,* polyb;printf("Welcome to use!\n");printf("\nPlease input the ploya include coef && exp:\n");polya=create(); /*调用建立链表函数，创建多项式A*/print(polya);printf("\nPlease input the ployb include coef && exp:\n");polyb=create(); /*同理，创建B*/print(polyb);printf("\nSum of the poly is:\n");polyadd(polya,polyb); /*调用一元多项式相加函数*/print(polya); /*调用输出函数，打印结果*/printf("\n");}。
实验二 线性表的链式存储
实验二线性表的链式存储
一、实验目的
1.掌握线性表的链式存储结构。
2.能熟练地利用链式存储结构实现线性表的基本操作。
3.能熟练地掌握链式存储结构中算法的实现。
二、实验内容
1.分别用头插法和尾插法建立带头结点的单链表。
2.实现单链表上的插入、删除、修改、查找、计数、输出等基本操作。
3.解决约瑟夫问题：假设有n个人按1、2、3、…、n的顺序围成一圈，现在，从第s个人开始按1、2、3、…、m的顺序报数，数到m的人出圈，接着从出圈的下一个人开始重复此过程，直到所有人出圈为止。
试用循环链表解决这个问题。
三、算法描述
1.第1题、第2题的算法提示
先定义单链表的数据类型，然后将头插法和尾插法、插入、删除、修改、查找、计数、输出等基本操作都定义成单独的子函数形式，最后在主函数中调用，并将每一种操作前后的结果输出，以查看每一种操作的效果。
2.第3题的算法提示
首先将n个人的信息建立成一个单循环链表，链表中的每个结点信息就是每个人的编号（1～n）。
然后利用循环找到出圈人位置的结
点，输出该结点的信息，再在链表中删除该结点，接着从删除的结点的后面重复此步骤，直到链表中剩下一个结点时停止循环，再把链表中的最后一个结点删除。
实验报告的要求与实验一相同。
线性表的链式存储结构实验报告
实验报告课程名称：数据结构与算法分析实验名称：链表的实现与应用实验日期：班级：数媒1401 姓名：范业嘉学号一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示；⑵基于所设计的存储结构实现线性表的基本操作；⑶编写一个主程序对所实现的线性表进行测试；⑷线性表的应用：①设线性表L1和L2分别代表集合A和B，试设计算法求A和B的并集C，并用线性表L3代表集合C；②（选做）设线性表L1和L2中的数据元素为整数，且均已按值非递减有序排列，试设计算法对L1和L2进行合并，用线性表L3保存合并结果，要求L3中的数据元素也按值非递减有序排列。
⑸设计一个一元多项式计算器，要求能够：①输入并建立多项式；②输出多项式；③执行两个多项式相加；④执行两个多项式相减；⑤（选做）执行两个多项式相乘。
三、数据结构设计1.按所用指针的类型、个数、方法等的不同，又可分为：线性链表（单链表）静态链表循环链表双向链表双向循环链表2.用一组任意的存储单元存储线性表中数据元素，用指针来表示数据元素间的逻辑关系。
四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L->next=NULL;for(i=0;i<n;i++){s=(Linklist)malloc(sizeof(Lnode));scanf("%d",&s->data);s->next=NULL;p->next=s; p=s;}}2.（1）两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist pa,pb,pc;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;} }pc->next=pa?pa:pb;free(Lb);}（2）两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode));p1=La->next;while(p1){flag=0;p2=Lb->next;while(p2){if(p1->data==p2->data){flag=1;break;}p2=p2->next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s->data=p1->data;q->next=s;q=s;}p1=p1->next;}q->next=Lb->next;return head;}3.（1）一元多项式的加法List addpoly(List pa,List pb) //一元多项式的加法{int n;List pc,s,p;pa=pa->next;pb=pb->next;pc=(List)malloc(sizeof(struct Linklist));pc->next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa->expn>pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if(pa->expn<pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef+pb->coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=n;s->next=NULL;p->next=s;p=s;}pb=pb->next;pa=pa->next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}while(pb!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}return pc;}（2）一元多项式的减法List subpoly(List pa,List pb) //一元多项式的减法{int n;List pc,s,p;pa=pa->next;pb=pb->next;pc=(List)malloc(sizeof(struct Linklist));pc->next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa->expn>pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if(pa->expn<pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=-pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef-pb->coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=n;s->next=NULL;p->next=s;p=s;}pb=pb->next;pa=pa->next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}while(pb!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=-pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}return pc;}（3）一元多项式的乘法void mulpolyn(polynomail pa,polynomail pb,polynomail &pc) {LNode *p,*q,*s,*hc;p=pa->next;q=pb->next;hc=pc;while(p!=NULL){while(q!=NULL){s=(polynomail)malloc(sizeof(LNode));hc->next=s;hc=hc->next;hc->coef=q->coef*p->coef;hc->expn=q->expn+p->expn;q=q->next;}p=p->next;q=pb->next;}hc->next=NULL;}五、测试结果2.3.六、心得体会（包括对于本次实验的小结，实验过程中碰到的问题等）1.首先书上给的链表输入是倒序的，写的时候想都没想就抄上去了，结果运行时发现问题，可是上网百度依然没有把问题解决，导致最后输出链表倒序的，并且链表的合并并集依旧是倒序的。
实验三+线性表的链式存储.doc
实验三线性表的链式存储【实验目的】1.掌握基本线性链式存储的类型定义及C语言实现；2.掌握基本线性表在链式存储结构中的各种基本操作。
【实验要求】1.学会定义一个链式存储结构体LNode；2.学会链式存储结构的初始化、清空、求线性表的长度、遍历、改值、插入（头插、尾插、固定位置插入）、删除（删头、删尾、固定位置删除）；3.学会用main函数调用定义的各个函数；【实验环境】VC++运行的环境【实验步骤及代码】一、创建VC工程环境二、编写、调试程序//一、包含库文件和类型定义#include <stdio.h>#include <stdlib.h>typedef char ElemType;//二、定义结构typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;//三、基本操作函数的定义//(1)创建一个带头结点的链表LinkList CreateList_L(int n){//逆序输入如n个元素的值，建立一个带表头结点的单链表LinkList L=(LinkList)malloc(sizeof(LNode));L->next=NULL;char ch;for(int i=n;i>0;--i){scanf("%c",&ch);p->data=ch;p->next=L->next;L->next=p;}return L;}//(2)链表的遍历函数void travel_L(LinkList s){LinkList p=s->next;while(p){printf("%c",p->data);p=p->next;}printf("\n");}//(3)返回链表L的第i个元素的值ElemType GetElem_L(LinkList L,int i){ LNode *p=L->next;int j=1;while (p&&j<i) {p=p->next;++j;}if (!p||j>i) {printf("i越界！");exit(1);}elsereturn p->data;}//(4)链表的i个位置插入一个值为e的节点void ListInsert_L(LinkList L,int i,ElemType e){ LinkList p=L;int j=0;while (p&&j<i-1) {p=p->next;++j;}if (!p||j>i-1) exit(1);else{s->data=e;s->next=p->next;p->next=s;}return;}//(5)链表中删除第i个元素void ListDelete_L(LinkList L,int i){LNode *p=L;int j=0;while (p->next&&j<i-1) {p=p->next;++j;}if(!(p->next)||j>i-1) exit(1);LNode *q=p->next;p->next=q->next;free(q);return;}//(6)删除链表的第一个节点void ListDeleteFist_L(LinkList L){ListDelete_L(L,1);}//(7)求一个链表的长度int ListLength_L(LinkList L){LNode *p=L;int j=0;while (p->next) {p=p->next;++j;}return j;}//(8)在一个链表的尾部查入一个值为e的节点void ListInsertLast_L(LinkList L,ElemType e){ ListInsert_L(L,ListLength_L(L)+1,e);}//(9)删除链表的尾节点void ListDeleteLast_L(LinkList L){ListDelete_L(L,ListLength_L(L));}//(10)把链表的第i个值改为evoid Listchange(LinkList L,int i,ElemType e){LNode *p=L;int j=0;while (p->next&&j<i) {p=p->next;++j;}if(!(p->next)||j>i) exit(1);p->data=e;return;}//(11)链表中找值为e的节点的位置int ListFind(LinkList L,ElemType e){LNode *p=L;int j=0;while (p->next&&(p->data!=e)) {p=p->next;++j;}if(!(p->next)||j>ListLength_L(L)) exit(1);elsereturn j;}//(12)清空一个链表void ListClear_L(LinkList L){while (L->next) {ListDeleteLast_L(L);}}//四、主调函数void main(){LinkList L=CreateList_L(6);travel_L(L);printf("链表的第2个元素是：");printf("%c\n",GetElem_L(L,2));printf("链表的第2个位置插入值为w后的链表：");ListInsert_L(L,2,'w');travel_L(L);printf("删除链表的第2个位置上的节点后的链表：");ListDelete_L(L,2);travel_L(L);printf("删除链表的头节点后的链表：");ListDeleteFist_L(L);travel_L(L);printf("\n");printf("当前链表的长度为：");printf("%d",ListLength_L(L));printf("\n");printf("链表的尾部插入z后：");ListInsertLast_L(L,'z');travel_L(L);printf("\n");printf("删除链表的尾节点后：");ListDeleteLast_L(L);travel_L(L);printf("\n");printf("把第二个节点的值改为Y后：");Listchange(L,2,'Y');travel_L(L);printf("\n");printf("找链表中值为Y的位置：");printf("%d",ListFind(L,'Y'));printf("\n");printf("清空链表：");ListClear_L(L);travel_L(L);printf("\n");}【实验结果】输入abcdef六个元素时的运行结果：。
数据结构实验报告实验一线性表链式存储运算的算法实现
昆明理工大学信息工程与自动化学院学生实验报告（201 —201学年第一学期）
课程名称：数据构造开课实验室：
年级、专业、班学号姓名
实验项目名称线性表链式储存运算的算法实现指导教师
年
成绩
月日
教
师
评教师署名：
语年月日一. 实验内容：
线性表链式储存运算的算法实现，实现链表的成立、链表的数据插入、链表的数据删除、链表的数据输出。
二.实验目的：
1.掌握线性表链式储存构造的 C语言描绘及运算算法的实现；
2.剖析算法的空间复杂度和插入和删除的时间复杂度；
3.总结比较线性表次序储存藏储与链式储存的各自特色。
三. 主要程序代码剖析：
LinkList creatListR1()序运转结果：
五. 实验总结：
经过线性表链式储存运算的算法实现的上机实验，我认识了链式的基来源理和方法，能编程对数据进行链式储存。
因为次序储藏是用物理地点上的毗邻关系来表示结点间的逻
辑关系，其插入或删除运算不方便，并且当表长变化较大时，难以确立适合的储存规模，
为认识决这些问题，我们采纳链接方式储存线性表。
因此，当线性表的长度变化较大，难
以预计其储存规模时，以采纳动向链表作为储存构造为好；假如关于屡次进行插入删除的
线性表，以采纳链表做储存构造。
链接储存是最常用的储存方法之一，它不单能够表示线
性表，还能够用来表示各样非线性的数据构造。
实验一 线性表的链式存储
实验一线性表的链式存储【实验时间】【实验地点】【实验目的和要求】1．掌握线性表的结构特点和表示方法；2．掌握线性表链式存储结构特性和基本操作算法；3．掌握用指针实现单链表的建立、输出、插入和删除的算法。
【实验类型】验证性【实验时数】2学时【实验设备】计算机【参考资料】1．数据结构题解2．C程序设计【实验内容】熟练掌握线性表的链式表示和实现方法，利用其定义具体的链表结点；利用链表的结构特点，建立单链表；利用链表结点间的指针关系，实现链表的插入和删除。
[具体要求](1) 建立单链表时，要首先输入链表长度，根据输入值来确定所建链表的结点个数；(2) 在单链表中插入新结点时，要给出结点的插入位置和数据域的值；(3) 在单链表中删除某个结点时，要给出要删结点的位置；(4) 要编写单链表的输出函数，以便能验证程序的执行结果。
【实验分析】1、实验的第一步应该建立单链表结点类型和程序所需的宏或数据类型，例如：#define NULL 0 //宏定义NULL的值为0#define LEN sizeof(struct node) //宏定义LEN，为申请结点空间时做准备typedef struct{ int a;float b;} elemtype; //定义elemtype类型，这里同学们可以根据自己的情况来自行定义。
typedef struct node{elemtype data; //data域为elemtype类型的，它应该包含两个子域：a和bstruct node *next;}NODE , *NODEPTR; //定义了单链表结点类型和单链表结点指针类型2、对单链表的四种操作进行实现。
(1) NODEPTR creatlink() 建立单链表的函数很明显这个函数的返回值时结点指针类型的，所以这个函数应该返回的时建立的单链表的头指针。
同学们可以根据自己的构思，从前往后或从后往前建立单链表。
此外，提醒同学们最好建立带有附加头结点的单链表。
链式存储实验报告
线性表的链式存储
一、目的：
1.顺序表链式存储结构的运算；
2.顺序表空间分配好后的各个运算的执行；
3.顺序表中的打印、输入、置空表、长度、插入、删除的运算等
二、功能层次图：
三、运行结果：
主菜单：
建立链表：
打印 线性表的链式存储
输入 置空表 长度 插入 删除
打印链表：
链表查询：
四、小结：
1.线性表的线性存储是将线性表中的结点采用连接的方式存储；
2.链式存储是用任意的存储单元来存储数据的，这个单元可以使连续的也可以是不连续的，所以链表的结点的逻辑次序和物理次序不一定相同；
3.链表中每个结点的的存储地址是放在前一个前驱的next，而第一个结点无前驱则头指针是head；
4.链表在查找运算中耗时较多，在查找是链表必须从头指针开始扫描才能获得；
5.链表在进行插入和输出运算，都只用修改指针的存放地址的单元。
存储结构描述实验报告
一、实验目的通过本次实验，使学生掌握数据结构中存储结构的基本概念，了解不同存储结构的特点和适用场景，能够根据具体问题选择合适的存储结构，提高编程能力和问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 线性表的存储结构描述（1）顺序存储结构：使用数组实现线性表的存储结构，通过数组的索引来访问元素。
顺序存储结构具有以下特点：优点：存储密度高，空间利用率高；随机访问速度快。
缺点：插入和删除操作需要移动大量元素，效率较低。
（2）链式存储结构：使用链表实现线性表的存储结构，每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点：优点：插入和删除操作效率高，只需修改指针；支持动态内存分配。
缺点：存储密度低，空间利用率较低；随机访问速度慢。
2. 栈的存储结构描述（1）顺序存储结构：使用数组实现栈的存储结构，栈顶元素位于数组的最后一个位置。
顺序存储结构具有以下特点：优点：存储密度高，空间利用率高；随机访问速度快。
缺点：插入和删除操作需要移动大量元素，效率较低。
（2）链式存储结构：使用链表实现栈的存储结构，每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点：优点：插入和删除操作效率高，只需修改指针；支持动态内存分配。
缺点：存储密度低，空间利用率较低；随机访问速度慢。
3. 队列的存储结构描述（1）顺序存储结构：使用数组实现队列的存储结构，队首元素位于数组的第一个位置，队尾元素位于数组的最后一个位置。
顺序存储结构具有以下特点：优点：存储密度高，空间利用率高；随机访问速度快。
缺点：插入和删除操作需要移动大量元素，效率较低。
（2）链式存储结构：使用链表实现队列的存储结构，队首元素位于链表的第一个节点，队尾元素位于链表的最后一个节点。
链式存储结构具有以下特点：优点：插入和删除操作效率高，只需修改指针；支持动态内存分配。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
贵州大学实验报告
学院：计算机科学与信息学院专业：信息安全班级：
chaintable *Buildtable(int x[],int y) {
chaintable *p,*head;
p=new chaintable;
head=p;
p->data=x[0];
for(int i=1;i<y;i++)
{
p->next=new chaintable;
p=p->next;
p->data=x[i];
}
p->next=NULL;
return head;
}
bool Deltable(chaintable *&head,int x) {
if(x<1)
return false;
chaintable *relief,*p=head;
for(int i=0;i<x-2;i++)
{
if(p->next==NULL)
return false;
p=p->next;
}
if(x==1)
{
relief=head;
head=head->next;
delete relief;
if(head!=NULL)
return true;
else
return false;
}
else
{
if(p->next!= NULL)
{
relief=p->next;
p->next=p->next->next;
delete relief;
return true;
}
else
return false;
}
}
bool Inserttable(chaintable *&head,int x,int y) {
if(y<0)
return false;
chaintable *p=head,*t=new chaintable;
t->data=x;
t->next=NULL;
if(y==0)
{
t->next=head;
head=t;
return true;
}
else
{
for(int i=0;i<y-1;i++)
{
if(p->next==NULL)
return false;
p=p->next;
}
t->next=p->next;
p->next=t;
return true;
}
}
void Disptable(chaintable *p)
{
while(p!=NULL)
{
cout<<p->data<<' ';
p=p->next;
}
cout<<endl;
}
bool Searchtable(chaintable *p,int &y,int x) {
if(x>=1)
{
for(int i=0;i<x-1;i++)
{
if(p->next==NULL)
return false;
p=p->next;
}
y=p->data;
return true;
}
else
return false;
}
int Location(chaintable *p,int x)
{
int i=1;
while(p!=NULL)
{
if(p->data==x)
return i;
i++;
p=p->next;
}
return 0;
}
void main()
{
int x,*temp,result;
chaintable *head;
cin>>x;
temp=new int[x];
for(int i=0;i<x;i++)
cin>>temp[i];
head=Buildtable(temp,x);
if(Deltable(head,2))
{
cout<<"删除操作结果：";
Disptable(head);
}
else
cout<<"操作失败！"<<endl;
if(Inserttable(head,23,5))
{
cout<<"将23插入到第五个数字后面的操作结果：";
Disptable(head);
}
else
cout<<"操作失败！"<<endl;
if(Searchtable(head,result,4))
{
cout<<"链表的第四个数是：";
cout<<"Search result:"<<result<<endl;
}
else
cout<<"操作失败！"<<endl;
cout<<"Please input your integer:";
cin>>x;
cout<<"Location:"<<Location(head,x)<<endl;
}
实验结果：
实
验
总
结
结果说明:1、第一行的8表示链表初始有8个数
2、第二行的8个数是链表初始化的8个数
3、第三行的结果是从链表删除了第二个数后的结果
4、第五行的结果是搜索链表第四个数
5、第六行是输入一个数要搜索的数（图中为25），第七行得出了搜索的结果。
注：请在实验报告后附程序清单。