实验8+链表

合集下载

链表实验报告

C 语言程序设计实验报告实验一：链表的基本操作一·实验目的1. 掌握链表的建立方法2. 掌握链表中节点的查找与删除3. 掌握输出链表节点的方法4. 掌握链表节点排序的一种方法5. 掌握C 语言创建菜单的方法6. 掌握结构化程序设计的方法二·实验环境1. 硬件环境：当前所有电脑硬件环境均支持2. 软件环境：Visual C++6.0三.函数功能1. CreateList // 声明创建链表函数2.TraverseList // 声明遍历链表函数3. InsertList // 声明链表插入函数4.DeleteTheList // 声明删除整个链表函数5. FindList // 声明链表查询函数四．程序流程图五．程序代码#include<stdio.h>#include<stdlib.h>typedef int Elemtype;typedef int Status;typedef struct node//定义存储节点{int data;//数据域struct node *next;//结构体指针} *linklist,node;//结构体变量，结构体名称linklist creat (int n)//创建单链表{linklist head,r,p;//定义头指针r,p,指针int x,i;head=(node *)malloc(sizeof(node));//生成头结点声明函数主函数 main 创建链表函数定义CreateList 定义链表遍历函数TraverseList定义链表查询函数FindList 定义链表插入函数在链表位置第pos 节点前插入包含数据val 的节点InsertList(PNode List, int pos, int val) 插入节点定义删除整个链表函数 DeleteTheList定义删除链表元素函数删除链表中的第pos 节点DeleteList(PNode List, int pos) 删除节点r=head;//r指向头结点printf("输入数字:\n");for(i=n;i>0;i--)//for 循环用于生成第一个节点并读入数据{scanf("%d",&x);p=(node *)malloc(sizeof(node));p->data=x;//读入第一个节点的数据r->next=p;//把第一个节点连在头结点的后面r=p;//循环以便于生成第二个节点}r->next=0;//生成链表后的断开符return head;//返回头指针}void output (linklist head)//输出链表{linklist p;p=head->next;do{printf("%3d",p->data);p=p->next;}while(p);printf("\n")}Status insert ( linklist &l,int i, Elemtype e)//插入操作{int j=0;linklist p=l,s;while(j<i-1 && p){p=p->next;++j;}if(!p || j>i-1)return -1;else{s=(node *)malloc(sizeof(node));s->data=e;s->next=p->next;p->next=s;return 1;}}Status delect ( linklist &l,int i, Elemtype &e)//删除操作{int j=0;linklist p=l,q;while(j<i-1 && p->next){p=p->next;++j;}if(!p->next || j>i-1)return -1;else{q=p->next;p->next=q->next;e=q->data;free(q);return 1;}}void combine(linklist la,linklist lb)//合并单链表{node *pa,*pb,*pc;linklist lc;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);}Status GetElem(linklist l,int i,Elemtype &e )//查找操作 {linklist p;int j;p=l->next;j=1;while(p && j<i){p=p->next;++j;}if(!p || j>i)return -2;e=p->data;return e;}void main(){linklist la,lb;int n;int i,j;Elemtype e;printf("请输入第一个链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入要查找元素的位置:\n");scanf("%d",&i);j=GetElem(la,i,e);printf("所要查找的元素是%d\n",j);printf("请输入插入位置和元素:\n");scanf("%d%d",&i,&e);insert(la,i,e);printf("插入后的链表:\n");output(la);printf("请输入要删除的位置:\n");scanf("%d",&i);delect(la,i,e);printf("删除的那个元素是:%d\n",e);printf("输出删除后的顺序表:\n");output(la);printf("请输入第一个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入第二个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);lb=creat(n);printf("输出链表:\n");output(lb);combine(la,lb);printf("输出合并后的链表:\n");output(la);六．运行结果七．心得体会通过本次实验我对链表有了更深的了解，对链表的插删操作、遍历、查找等基本上掌握了。

链表的实验报告

{
front->next=alist.front->next;
cout<<"复制构造函数"<<endl;
}
//touchafa
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
front->next=NULL;
找到要插入的结点的前一个结点新结点的指针域指向p然后p前面的结点指向这个新的结点这样这个新的结点就插入到了链表里面3代码的时间复杂度
数据结构实验报告
1.
2.
2.1
2.2
2.3
算法一：
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
T x=q->data;
delete q;
return x;
}
[1]算法功能：删除链表中的某个元素
[2]思想：删除就是先找到要删除的元素的前面的元素，然后前面的这个结点直接指向这个结点的下一个结点，然后再把这个指针删除。
[3]时间复杂度：O(n)
[4]代码逻辑：
1.从第一个结点开始，查找第i-1个元素，设为P指向该结点，如果查找失败则抛出异常
front->next=NULL;
for(int i=n-1;i>=0;i--)
{
Node<T>*s=new Node<T>;
s->data=a[i];

顺序表-链表实验报告.总结

实验报告实验目的：学生管理系统（顺序表）实验要求：1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序：#include <stdio.h>#include <string.h>#include<stdlib.h>#define MaxSize 1000typedef struct{char xh[40];char xm[40];int cj;}DataType; //学生的结构typedef struct {DataType data[MaxSize]; //定义表的数据类型int length; //数据元素分别放置在data[0]到data[length-1]当中} SqList; //表的结构void liebiao(SqList *L) //建立表格{int k,n;char q;printf("请输入,输入学生的个数：\n");fflush(stdin);scanf("%d",&n);for(k=0;k<=n-1;k++){printf("请输入学生学号\n");scanf("%s",L->data[k].xh);printf("请输入学生名字\n");scanf("%s",L->data[k].xm);printf("请输入学生成绩\n");scanf("%d",&L->data[k].cj);}L->length=n;}void qb(SqList *L) //全部输出{int k,w;for(k=0;k<L->length;k++){w=k+1;printf("第%d位学生：",w);printf("%s %s %d\n",L->data[k].xh,L->data[k].xm,L->da ta[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;}else if((i<0)||(i>L->length)){printf("程序溢出，不符合");return 0;}else{for(j=L->length-1;j>=i;j--){strcpy(L->data[j+1].xh,L->data[j].xh);strcpy(L->data[j+1].xm,L->data[j].xm);L->data[j+1].cj=L->data[j].cj;}strcpy(L->data[i].xh,xs->xh);strcpy(L->data[i].xm,xs->xm);L->data[i].cj=xs->cj;L->length=L->length+1;}return 0;}int cz(SqList *L) //查找信息{char xh[40];char xm[40];int cj;int i=0,u;printf(" 1、按学号查询 \n");printf(" 1、按姓名查询 \n");printf(" 1、按成绩查询 \n");printf("请选择：");fflush(stdin);scanf("%d",&u);if (u==1){printf("请输入要查找学生的学号：");scanf("%s",xh);for(i=0;i<L->length;i++){if(strcmp(L->data[i].xh,xh)==0)return i;}}if (u==2){printf("请输入要查找学生的姓名：");scanf("%s",xm);for(i=0;i<L->length;i++){if(strcmp(L->data[i].xm,xm)==0)return i;}}if (u==3){printf("请输入要查找学生的成绩：");scanf("%s",cj);for(i=0;i<L->length;i++){if(L->data[i].cj,&cj)return i;}}return -1;//*如果没找到，返回-1}int cz2(SqList *L) //删除查找的函数{char xh[40];char xm[40];int i=0,h;printf(" 1、按学号删除 \n");printf(" 2、按姓名删除 \n");printf("请选择：");fflush(stdin);scanf("%d",&h);if (h==1){printf("请输入要删除学生的学号：");scanf("%s",xh);for(i=0;i<L->length;i++){if(strcmp(L->data[i].xh,xh)==0) //判断输入和已知学号一样不return i;}}else if (h==2){printf("请输入要删除学生的姓名：");scanf("%s",xm);for(i=0;i<L->length;i++){if(strcmp(L->data[i].xm,xm)==0) //判断输入姓名和已知姓名一样不return i;}}return -1;}void sc(SqList *L) //删除函数{int i,j;printf("请先选择您要删除的学生信息的方式：\n");scanf("%d",&j);i=cz2(L);if(i==-1){printf("没有查到要删除的学生信息");return;}for(j=i;j<L->length;j++) // 要删除学生以后的学生整体上调一位{L->data[j].cj=L->data[j+1].cj; //就是后一个覆盖了前一个strcpy(L->data[j].xh,L->data[j+1].xh);strcpy(L->data[j].xm,L->data[j+1].xm);}L->length--;printf("该学生信息已被删除！\n");}int bc(SqList *L){return (L->length);}int main() //主体大函数{int i,k;SqList *L; //定义顺序表的指针DataType *xs;L=(SqList *)malloc(sizeof(SqList)*MaxSize);char q;ee:rewind(stdin);{printf(" 学生管理系统 \n"); //函数的各个结构printf(" \n");printf(" \n");printf(" \n");printf(" 建立表格请输入1 \n");printf(" 求表长请输入2 \n");printf(" 插入请输入3 \n");printf(" 查找请输入4 \n");printf(" 删除请输入5 \n");printf(" 列表请输入6 \n");printf(" 退出请按0 \n");printf(" 请输入");scanf("%c",&q);}if(q=='1'){rewind(stdin);liebiao(L);goto ee;}if(q=='2'){rewind(stdin);bc(L);printf("共%d个学生\n",L->length);goto ee;}if(q=='3'){rewind(stdin);printf(" 插入 \n");printf("\t\t 请输入要添加的学生信息: \n");xs=(DataType *)malloc(sizeof(DataType));printf("请输入学生学号\n");scanf("%s",xs->xh);printf("请输入学生名字\n");scanf("%s",xs->xm);printf("请输入学生成绩\n");scanf("%d",&xs->cj);printf("请输入要插入的位置：\n");rewind(stdin);scanf("%d",&i);cr(L,xs,i);goto ee;}if(q=='4'){rewind(stdin);printf(" 查找 \n");printf(" 查询学生信息 \n");i=cz(L);if(i!=-1){printf("%s %s %d\n",L->data[i].xh,L->data[i].x m,L->data[i].cj);}else{printf("信息不存");}goto ee;}if(q=='5'){rewind(stdin);printf(" 删除 \n"); printf(" 删除学生信息 \n");sc(L);goto ee;}if(q=='6'){rewind(stdin);printf(" 列表 \n");qb(L);goto ee;}if(q=='0') {printf("谢谢使用\n");}if(!(q=='1'||q=='2'||q=='3'||q=='4'||q=='5'||q=='5'||q=='0 ')){goto ee;}system ("pause");return 0;}建表：否是否实验目的：学生管理系统(链表)实验要求：1.建表2.删除3.列表4.退出源程序：#include<stdio.h>#include<string.h>#include<stdlib.h>struct xuesheng{char xh[7];char xm[40];int cj;struct xuesheng *next;};struct xuesheng *cha_ru(struct xuesheng *x){struct xuesheng *p,*q;int c;do{if(x==0){ x=(struct xuesheng *)malloc(sizeof(struct xuesheng));printf("input xh:"); scanf("%s",(*x).xh);printf("input xm:"); scanf("%s",(*x).xm);printf("input cj:"); scanf("%d",&(*x).cj);(*x).next=0; }else{ p=x;while((*p).next!=0){p=(*p).next;};q=(struct xuesheng *)malloc(sizeof(struct xuesheng));printf("input xh:"); scanf("%s",(*q).xh);printf("input xm:"); scanf("%s",(*q).xm);printf("input cj:"); scanf("%d",&(*q).cj);(*p).next=q;(*q).next=0; }printf("ni hai ji xu me? 1/2:");scanf("%d",&c);}while(c==1);return(x);}int link_len(struct xuesheng *x){struct xuesheng *p;int l=0;p=x;if(p!=0)do{l=l+1;p=p->next;}while(p!=0);return(l);}struct xuesheng *shan_chu(struct xuesheng *x){struct xuesheng *p,*q,*t;int k,l,i;p=x;q=x;l=link_len(x);printf("input shan chu jie dian xu hao :");scanf("%d",&k);if(k<=0||k>l)printf("error data!\n");if(k==1){ x=p->next;t=p;free(t);}if(k>1&&k<=l){ for(i=1;i<=k-2;i=i+1)p=p->next;t=p->next;for(i=1;i<=k;i=i+1)q=q->next;p->next=q;free(t); }printf("vvvvvvv shan chu wan bi ! vvvvvvv\n");return(x);}void lie_biao(struct xuesheng *x){struct xuesheng *p;int l;p=x;if(p==0) printf("gai biao wei kong!\n");else do{printf("%20s% 20s%7d\n",(*p).xh,(*p).xm,(*p).cj);p=(*p).next;}while(p!=0);l=link_len(x);printf(" l=%d\n",l);}main(){struct xuesheng *s_head;int n;s_head=0;do{printf("1:cha ru\n");printf("2:cha zhao\n");printf("3:shan chu\n");printf("4:lie biao\n");printf("5:tui chu\n");printf("input 1---5:");scanf("%d",&n);switch(n){case 1: s_head=cha_ru(s_head);break; /* case 2: cha_zhao(s_head);break;*/ case 3: s_head=shan_chu(s_head);break; case 4: lie_biao(s_head);break;}}while(n==1||n==3||n==4);printf("\n");return 0;}主函数：删除：总结：顺序表存储位置是相邻连续的，可以随即访问的一种数据结构，一个顺序表在使用前必须指定起长度，一旦分配内存，则在使用中不可以动态的更改。

6.2.8链表 - 链表_实验项目

实验项目一1．实验目的：（1）熟练掌握链表的定义与构造方法。

（2）熟练使用结构、函数、指针进行程序设计2．实验任务（1）实验内容：编写程序，输入若干平面点坐标，建立一个平面点坐标链表单向链表，跟踪程序的执行过程。

（2）实验要求：链表结点结构定义为：struct NODE{float x, y;struct NODE *next;};要求自定义函数CreateList()用于建立单向链表，输入(32767,32767)为止。

测试用例：(1,1)(0,0)(-1,1)(32767,32767)3．实验分析（1）问题分析：链表的构造是动态的，因此在使用动态存储分配函数（典型为malloc）时要注意其用法。

另外，构造的链表是必须进行初始化，未初始化的指针是非常危险的，它是程序崩溃的主要原因。

（2）实现要点：指针调试需要认真、仔细。

4．实验思考题可不可以不使用动态存储技术存储链表数据对象呢？是否可以尝试使用静态存储技术构造链表对象？实验项目二1．实验目的（1）熟练掌握单向链表的建立方法。

（2）熟练掌握单向链表的基本操作。

2．实验任务（1）实验内容：实现链表结点的删除函数void DeleteNode(struct NODE *head, int pos)，删除位置pos处的结点。

（2）实验要求：编写程序，先输入若干平面点坐标，建立一个单向链表，然后再输入一个pos值(pos值要小于结点个数)，调用本函数删除链表中位置为pos的数据。

结点结构为：struct NODE{float x, y;struct NODE *next;};3．实验分析（1）问题分析：结点的删除也分为三种情况，即被删除结点分别在表头、表尾或表中。

不过对于单向链表，表尾的删除操作与表中删除操作同样可以合并。

（2）实现要点：在删除表头结点时，DeleteNode函数必须确保head指针指向第2个结点。

如果被删除结点位于表中，则与插入结点一样还需要获得指向待删除结点前一结点的指针。

链表实验报告总结

篇一：链表实验报告数据结构实验报告姓名；方钢学号：20105567 专业：电子商务班级： 10-1班指导教师：实验时间：实验地点：新区实验楼4楼（实验题目）单链表实验1.实验内容和要求1.1实验要求①本次实验中的链表结构均为带头结点的单链表；②链表结构定义，算法实现放入库文件“linklist.h”；运算和变量命名直观易懂，并有相应的注释1.2实验内容<1>求链表中第i个结点的指针（函数），若不存在，则返回null。

<2>在第i 个结点前插入值为x的结点。

<3>删除链表中第i个元素结点。

<4>在一个递增有序的链表l中插入一个值为x的元素，并保持其递增有序特性。

<5>将单链表ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），申请2个头结点，把分开的奇数项和偶数项分别链接到这2个头结点上，然后再将这两个新链表同时输出在屏幕上，并保留原链表的显示结果，以便对照求解结果。

<6>求两个递增有序链表l1和l2中的公共元素，并以同样方式连接成链表l3。

2.实验目的2.1 理解线性表的链式存储结构。

2.2熟练掌握单链表结构及有关算法的设计。

2.3根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法。

3.数据结构设计<1>求链表中第i个结点的指针（函数），若不存在，则返回null。

实验代码node *l,*p;int i; createnode(*&l); //尾插法创建一个链表，cout<<链表包含：<<endl;p=l->next; while(p){cout<<p->data<<,;p=p->next; }cout<<endl;cout<<请输入待求元素序号：;cin>>i; locatenode (l, i, &p );if(p!=null)cout<<序号<<i<<的元素值为：<<p->data<<endl;elsecout<<null<<endl;destroylist(l); //销毁链表，释放heap内存_crtdumpmemoryleaks(); //debug 模式下检测是否内存泄漏测试截图<2>在第i个结点前插入值为x的结点。

淮阴工学院c++实验报告实验八结构和链表

实验八结构体与链表一、实验目的和要求1．掌握结构体类型、结构体变量的基本概念；2．掌握结构体指针、结构体数组的应用；3．掌握链表的基本概念；4．掌握链表的基本操作与应用，包括建立链表、遍历链表、插入结点、删除结点、查找结点等。

二、相关知识点1．结构体类型：定义：struct 结构类型名{数据类型数据项1;数据类型数据项2;…………………….数据类型数据项n;}2．结构体变量：1．定义：（1）间接定义法──先定义结构类型、再定义结构变量struct 结构类型名结构变量；（2）直接定义法──在定义结构类型的同时定义结构变量struct 结构类型名{………}结构变量表；2．结构变量的初始化与引用：（1）如：struct std_info student={"000102","张三","男",{1980,9,20}};（2）结构变量的引用规则，对于结构变量，要通过成员运算符“.”，逐个访问其成员即结构变量.成员3．结构体指针：（1）使用指向结构变量的指针来访问结构变量的各个成员。

struct std_info *p_std=&student（2）使用指向结构数组的指针来访问结构数组struct std_info *p_std=student;4．结构体数组结构数组的每一个元素，都是结构类型数据，均包含结构类型的所有成员。

struct std_info student[3]={{“000102”, “张三”,“男”,{1980,9,20}},{“000105”,“李四”,“男”,{1980,8,15}},{“000112”, “王五”,“女”,{1980,3,10}}};5．链表的基本操作与应用：（1）建立链表：创建静态链表，创建动态链表（2）访问链表（3）插入结点（4）删除结点（5）查找结点（6）链表的释放。

三、实验内容1.定义一个学生成绩结构体类型，包含“学号”、“姓名”、“性别”、“年龄”、“班级”、“英语”、“数学”、“物理”、“总分”、“名次”等信息。

数据结构顺序表链表试验报告

数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便能够高效地进行检索和操作。

顺序表和链表是两种常见的数据结构，它们在实际应用中都有各自的优势和局限性。

本报告将对顺序表和链表进行试验比较，以评估它们在不同场景下的性能和适合性。

二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异，并分析其时间复杂度和空间复杂度。

通过实验结果，可以对不同场景下选择合适的数据结构提供参考。

三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表；b. 在表尾插入一个元素；c. 在表头插入一个元素；d. 在表的中间位置插入一个元素；e. 删除表尾的一个元素；f. 删除表头的一个元素；g. 删除表的中间位置的一个元素；h. 查找一个元素；i. 遍历整个顺序表。

2. 链表实验a. 创建一个包含100个节点的链表；b. 在链表尾部插入一个节点；c. 在链表头部插入一个节点；d. 在链表的中间位置插入一个节点；e. 删除链表尾部的一个节点；f. 删除链表头部的一个节点；g. 删除链表的中间位置的一个节点；h. 查找一个节点；i. 遍历整个链表。

四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms；b. 在表头插入一个元素的平均时间为0.2ms；c. 在表的中间位置插入一个元素的平均时间为0.5ms；d. 删除表尾的一个元素的平均时间为0.1ms；e. 删除表头的一个元素的平均时间为0.2ms；f. 删除表的中间位置的一个元素的平均时间为0.5ms；g. 查找一个元素的平均时间为1ms；h. 遍历整个顺序表的平均时间为10ms。

2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms；b. 在链表头部插入一个节点的平均时间为0.1ms；c. 在链表的中间位置插入一个节点的平均时间为0.5ms；d. 删除链表尾部的一个节点的平均时间为0.2ms；e. 删除链表头部的一个节点的平均时间为0.1ms；f. 删除链表的中间位置的一个节点的平均时间为0.5ms；g. 查找一个节点的平均时间为2ms；h. 遍历整个链表的平均时间为5ms。

[线性表链表实验报告]链表线性表

[线性表链表实验报告]链表线性表实验一：线性表运算的实现班级姓名学号一、实验预备知识1 复习C++中编写函数的相关内容。

2 复习如何用主函数将多个函数连在一起构成一个C++完整程序。

二、实验目的1 掌握线性表的顺序和链式存储结构2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1 编写初始化并创建线性表和输出线性表的算法。

2 编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。

3 编写一个主函数，将上面函数连在一起，构成一个完整的程序。

4将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。

四、实验步骤◇顺序表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。

2．初始化并建立顺序表。

3．编写顺序表输出算法。

（内存中开辟的单元数为8）4．依次插入3，21，15三个数，分别插入在第4，6和2位置，每插入一次都要输出一次顺序表。

5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次顺序表。

◇单链表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。

2．建立一个带表头结点的单链表（前插入法和尾插入法都可以）。

3．编写单链表输出算法。

4．依次插入3，21，15三个数，分别插入在第4，6和12位置，每插入一次都要输出一次单链表。

5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次单链表。

五、实验程序◇顺序表实验//LinkList.h#define MAXSIZE 8typedef int DataType;typedef struct{DataType data[MAXSIZE];int last;}Seqlist;void creat_seqlist(Seqlist &s);void display_seqlist(Seqlist &s);int insert_seqlist(Seqlist &s, int i, DataType x); int delet_seqlist(Seqlist &s, int i);//LinkList.cpp#include#include”Seqlist.h”void creat_seqlist(Seqlist &s){int x, i = 0;coutcin>>x;while(x != -1){s.data[i] = x;cin>>x;i ++;}st = i-1;}void display_seqlist(Seqlist &s){int i;coutfor(i = 0; icoutcout}int insert_seqlist(Seqlist &s, int i, DataType x) {int j;if(st == MAXSIZE-1){}cout st + 2){ cout= i-1;j --) s.data[j+1] = s.data[j]; s.data[i-1] =x ; st ++; return 1;int delet_seqlist(Seqlist &s, int i){int j;if(i st+1){coutreturn -1;}for(j = i; js.data[j-1] = s.data[j];st --;return 1;}//main.cpp#include#include”Seqlist.h”int main(){int x,d,s;Seqlist s_list;creat_seqlist(s_list);cout>d; cout>x; s=insert_seqlist(s_list ,d,x); if(s==1){ cout>d; s=delet_seqlist(s_list,d);}if(s==1){ cout运行结果:请输入数据（以输入-1结束）12 25 7 42 19 38 -1顺序表为：12 25 7 42 19 38插入操作请输入插入的位置:4请输入要插入的数据：3插入后的顺序表为：12 25 7 3 42 19 38请输入插入的位置:6请输入要插入的数据：21插入后的顺序表为：12 25 7 3 42 21 19 38请输入插入的位置:2请输入要插入的数据：15表满！删除操作请输入删除元素的位置：5删除后的顺序表为：12 25 7 3 21 19 38请输入删除元素的位置：3删除后的顺序表为：12 25 3 21 19 38请输入删除元素的位置：12不存在该元素！Press any key to continue◇单链表实验//LinkList.htypedef int DataType;typedef struct Node{DataType data;struct Node *next;}LNode,*LinkList;void Creat_LinkList(LinkList &L); //创建链表void Show_LinkList(LinkList &L); //显示数据LNode * Get_LinkList(LinkList &L, int i); //获得第i个结点的地址int Insert_linklist(LinkList &L,int i,DataType x); //插入结点int Delete_LinkList(LinkList &L,int i); //删除结点//LinkList.cpp#include#include”LinkList.h”void Creat_LinkList(LinkList &L){LNode *s;L = NULL;s = new LNode;s->next = L;L = s;int x;}//头插法创建带头结点的链表 cout>x; while(x != -1){ s = new LNode; s->next = L; L->data = x; L = s; cin>>x; } void Show_LinkList(LinkList &L){LNode *p;p = L->next;while(p!=NULL){coutdatap = p->next; //显示数据cout}LNode * Get_LinkList(LinkList &L, int i){int j = 1;LNode *q;q = L->next;while(q != NULL && jq = q->next;j++;}return q;}//获得第i个结点的地址int Insert_LinkList(LinkList &L, int i, DataType x)//插入结点 {LNode *p, *s;p = Get_LinkList(L,i-1);if(p == NULL){}coutdata = x; s->next = p->next; p->next = s; return 1; }int Delete_LinkList(LinkList &L,int i)LNode *p, *s;p = Get_LinkList(L,i-1);if(p == NULL){//删除结点 coutnext == NULL){ coutreturn 0;}else{s = p->next;p->next = s->next; delete s;return 1;}}//main.cpp#include #include”LinkList.h”int main(){int x,d,s;LinkList H;Creat_LinkList(H); Show_LinkList(H);} cout>d; cout>x; s = Insert_LinkList(H,d,x); if(s == 1){ cout>d; s = Delete_LinkList(H,d); if(s == 1){ cout 运行结果：请输入数据（以输入-1结束） 12 25 7 42 19 38 -1 单链表为：38 19 42 7 25 12插入操作请输入插入的位置:4 请输入要插入的数据：3 插入后的单链表为： 38 19 42 3 7 25 12 请输入插入的位置:6 请输入要插入的数据：21 插入后的单链表为：38 19 42 3 7 21 25 12 请输入插入的位置:12 请输入要插入的数据：15 插入位置错误!删除操作请输入删除元素的位置：5 删除后的单链表为：38 19 42 3 21 25 12 请输入删除元素的位置：3 删除后的单链表为： 38 19 3 21 25 12请输入删除元素的位置：12 插入位置的前驱结点不存在!。

链表(单链表双向循环)实验报告讲解

数据结构实验报告T1223-3-21余帅实验一实验题目：仅仅做链表部分难度从上到下1.双向链表，带表头，线性表常规操作。

2.循环表，带表头，线性表常规操作。

3.单链表，带表头，线性表常规操作。

实验目的：了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。

实验要求：常规操作至少有：1.数据输入或建立2.遍历3.插入4.删除必须能多次反复运行实验主要步骤：1、分析、理解给出的示例程序。

2、调试程序，并设计输入数据，测试程序的如下功能：1.数据输入或建立2.遍历3.插入4.删除单链表示意图：headhead head 创建删除双向循环链表示意图：创建程序代码://单链表#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node *next;};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;searchp = searchp->next;count++;}searchp->next = NULL;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>=count)return range_error;node *newnodep=new node,*searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next=followp->next; //注意此处的次序相关性followp->next=newnodep;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp;if(empty())return underflow;searchp = headp->next;cout<<"连表中的数据为："<<endl;while(searchp!=NULL){cout<<searchp->data<<" ";searchp = searchp->next;}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonfacevoid clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择：";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置："<<endl;cin>>position;cout<<"请输入插入数据："<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '3':cout<<"输入你要删除的位置："<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统，欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起，您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}/* 功能：用双向循环链表存储数据1.创建链表2.增加结点3.删除结点4.遍历链表制作人：余帅内容：239行*/#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node * next; //指向后续节点node * pre; //指向前面的节点};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;headp->pre = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;headp->pre = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;newnodep->pre = searchp;searchp = searchp->next;count++;}searchp->next = headp;headp->pre = searchp;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>count+1)return range_error;node *newnodep=new node;node *searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next = searchp;searchp->pre = newnodep;followp->next = newnodep;newnodep->pre = followp;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句searchp->next->pre = followp;delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp1,*searchp2;if(empty())return underflow;searchp1 = headp;searchp2 = headp;cout<<"连表中的数据为："<<endl;cout<<"从左至右读取：";while (searchp1->next!=headp ) {searchp1 = searchp1 ->next;cout << searchp1->data<<" ";}cout<<endl;cout<<"从右至左读取：";while (searchp2->pre!=headp ) {searchp2 = searchp2 ->pre;cout << searchp2->data<<" ";}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonface void clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择：";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置："<<endl;cin>>position;cout<<"请输入插入数据："<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '3':cout<<"输入你要删除的位置："<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功！！！"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统，欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起，您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}运行结果：1.创建链表：2.增加结点3．删除结点心得体会：本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。

实验链表实验报告

实验链表实验报告一、实验目的本次实验的主要目的是深入理解链表这种数据结构的概念、特点和操作方法，并通过实际编程实现来提高对链表的应用能力。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

三、实验原理链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。

与数组不同，链表的内存分配是动态的，并且可以方便地进行插入和删除操作，而不需要移动大量的元素。

链表分为单向链表、双向链表和循环链表等多种类型。

在本次实验中，我们主要实现单向链表。

单向链表的节点结构通常包含数据域和指针域。

数据域用于存储节点的数据，指针域用于指向下一个节点。

通过遍历链表的指针，可以访问链表中的每个节点。

四、实验内容1、链表节点的定义｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀2、链表的创建｀｀｀cppListNode createList(）｛ListNode head ＝ NULL;ListNode tail ＝ NULL;int num;cout ＜＜＂请输入链表中的数字（输入－1 结束）：＂；cin ＞＞ num;while （num!＝－1) ｛ListNode newNode ＝ new ListNode(num)；if （head ＝＝ NULL) ｛head ＝ newNode;tail ＝ newNode;｝ else ｛tail>next ＝ newNode;tail ＝ newNode;｝cin ＞＞ num;｝return head;｝｀｀｀3、链表的遍历｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝cout ＜＜ endl;｝｀｀｀4、链表的插入｀｀｀cppvoid insertNode(ListNode& head, int position, int value) ｛ListNode newNode ＝ new ListNode(value)；if （position ＝＝ 0) ｛newNode>next ＝ head;head ＝ newNode;return;｝ListNode curr ＝ head;int count ＝ 0;while （curr!＝ NULL ＆＆ count ＜ position 1) ｛curr ＝ curr>next;count+＋；｝if （curr ＝＝ NULL) ｛cout ＜＜＂插入位置超出链表长度" ＜＜ endl; return;｝newNode>next ＝ curr>next;curr>next ＝ newNode;｝｀｀｀5、链表的删除｀｀｀cppvoid deleteNode(ListNode& head, int position) ｛if （head ＝＝ NULL) ｛cout ＜＜＂链表为空，无法删除" ＜＜ endl; return;｝if （position ＝＝ 0) ｛ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;ListNode prev ＝ NULL;int count ＝ 0;while （curr!＝ NULL ＆＆ count ＜ position) ｛prev ＝ curr;curr ＝ curr>next;count+＋；｝if （curr ＝＝ NULL) ｛cout ＜＜＂删除位置超出链表长度" ＜＜ endl; return;｝prev>next ＝ curr>next;delete curr;｝｀｀｀五、实验结果通过对上述链表操作函数的调用，我们成功地创建、遍历、插入和删除了链表中的节点。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

实验八
一、编程题
建立一条无序链表，并输出这条链表上个节点的值。

设计一个函数，将这条链表构成一条新的逆序链表，即将链表头当尾，链表尾当头。

输出这条新链表上节点的值。

用以下一组数据测试程序的正确性：
学号C++成绩英语成绩
38 98 90
45 90 80
49 75 63
50 86 49
二、N个人围成一圈，他们的序号依次为1~n，从第一个人开始顺序报数1、2、3……、m，报到m者退出圈子，并输出退出圈子的人的序号。

用一个结点的环形链表模拟围成一圈的人。

假定有10个人围城一圈，凡报到5者退出圈子，则退出圈子的人的序号依次为5、10、6、2、9、8、1、4、7，最后留在圈中的人是3号。

是单向环形链表的结构，其中head指向第一个人。

struct Node{
int x;
Node *next;
};
要求：
1.函数Node * creat (int n)用来创建一个有n个节点的环形链表，他们的序号依
次为1~n，函数返回头结点；
2.函数void del(Node *h , int m) 实现从第一个人开始顺序报数1、2、3……、
m，报到m者退出圈子，并输出退出圈子的人的序号。

接着再顺序报数，直
到圈子中留下一个人为止。

3.主函数要求从键盘输入m,n的值，并调用函数creat函数完成建立环形链表，
和del函数依次输出退出圈子的人的序号，找出圈子中留下的最后一个人。

三、编程题
用函数函数Node * creat()建立两个有序的同结构的单向链表（结点包含一个整型数和一个指向本结点的类型的指针）；用函数merge(Node * h1 , Node * h2 )合并这两个链表；用函数void print(Node * h)输出结果，主函数如下。

用下列数据测试程序的正确性。

链表1：
5，9，21，36，58，79，81
链表2：
3，4，8，16，34，78，90，100，101
void main( ){
Node *h1, *h2, *h3;
h1=creat( );
h2= creat( );
print(h1);
print(h2);
h3=merge (h1,h2);
print(h3);
del(h1);
del(h2);
del(h3);
}。