链表实验报告
链表实验报告

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);六.运行结果七.心得体会通过本次实验我对链表有了更深的了解,对链表的插删操作、遍历、查找等基本上掌握了。
数据结构单链表实验报告

数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。
实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。
利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤:1. 创建单链表在创建单链表时,先定义一个结构体Node来表示链表中的节点,节点包括数据域和指针域,指针域指向下一个节点。
然后,用指针p指向链表的头节点,将头节点的指针域初始化为NULL。
2. 插入节点在单链表中插入节点的操作分为两种情况:- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况,先将新节点的指针域指向要插入的位置的下一个节点,再将要插入的位置的指针域指向新节点即可。
3. 删除节点删除链表节点的操作同样分为两种情况:- 删除头节点- 删除中间或尾部节点要删除头节点,先用一个指针将头节点指向的下一个节点保存起来,再将头节点释放掉。
要删除中间或尾部节点,先用一个指针指向要删除节点的前一个节点,然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点,最后将要删除的节点释放掉。
4. 单链表逆序单链表逆序可以使用三个指针来完成,分别为pre指针、cur指针和next指针。
首先将pre指针和cur指针指向NULL,然后循环遍历链表,将cur指针指向当前节点,将next指针指向当前节点的下一个节点,然后将当前节点的指针域指向pre指针,最后将pre指针和cur指针向前移动一个节点,继续进行循环。
5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法,将两个指针p1和p2都指向链表头,然后p1每次向前移动一个节点,而p2每次向前移动两个节点,当p2指向了链表尾部时,p1指向的节点即为中间节点。
6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法,在链表中定义两个指针p1和p2,p1指向链表头,p2指向第K个节点,然后p1和p2同时向前移动,直到p2指向链表尾部,此时p1指向的节点即为要删除的节点。
链表的实验报告

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];
链表基本操作实验报告

while(p&&j<i) {p=p->next;j++;} if(p==NULL||j>i)
printf("插入位置不正确\n"); else{s=(LNode *)malloc(sizeof(LNode));
{printf("%d ",p->data); p=p->next;} } printf("\n"); }
int LinkedListLength (LinkedList L) {LinkedList p;
int j; p=L->next; j=0; while(p!=NULL)
{j++;p=p->next;} return j; }
8.向链表中插入元素
插入元素之后的链表 9.从链表中删除元素
删除位置为 6 的元素(是 3)
10.清空单链表
五、 实验体会
经过这次单链表基本操作实验,自己的编程能力有了进一步的提高,认识到自 己以前在思考一个问题上思路不够开阔,不能灵活的表达出自己的想法,虽然在 打完源代码之后出现了一些错误,但是经过认真查找、修改,最终将错误一一修 正,主要是在写算法分析的时候出现了障碍,经过从网上查找资料,自己也对程 序做了仔细的分析,对单链表创建、插入、删除算法画了详细的 N-S 流程图。
r=L; r 指向头结点
使用 malloc 函数动态分配存储空间,指针 p 指向新开辟的结点,并将元素存
放到新开辟结点的数据域,
链表实验报告总结

篇一:链表实验报告数据结构实验报告姓名;方钢学号:20105567 专业:电子商务班级: 10-1班指导教师:实验时间:实验地点:新区实验楼4楼(实验题目)单链表实验1.实验内容和要求1.1实验要求①本次实验中的链表结构均为带头结点的单链表;②链表结构定义,算法实现放入库文件“linklist.h”;运算和变量命名直观易懂,并有相应的注释1.2实验内容<1>求链表中第i个结点的指针(函数),若不存在,则返回null。
<2>在第i 个结点前插入值为x的结点。
<3>删除链表中第i个元素结点。
<4>在一个递增有序的链表l中插入一个值为x的元素,并保持其递增有序特性。
<5>将单链表l中的奇数项和偶数项结点分解开(元素值为奇数、偶数),申请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的结点。
链表实验报告1

1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。
单链表操作的选择以菜单形式浮现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满 6.遍历链表(设为输出元素) 7.从链表中查找元素 8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
设编号为 1,2,3,……, n 的 n(n>0)个人按顺时针方向围坐一圈,每一个人持有一个正整数密码。
开始时任选一个正整数做为报数上限 m,从第一个人开始顺时针方向自 1 起顺序报数,报到 m 时住手报数,报 m 的人出列,将他的密码作为新的m 值,从他的下一个人开始重新从 1 报数。
如此下去,直到所有人全部出列为止。
令n 最大值取 30。
要求设计一个程序摹拟此过程,求出出列编号序列。
struct node //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};/* 定义 DataType 为 int 类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;LinkedList LinkedListInit(){ //函数功能:对链表进行初始化参数:链表(linklist L) 成功初始化返回 1, 否则返回 0 }void LinkedListClear(LinkedList &L){//函数功能:把链表清空参数:链表(linklist L) 成功清空链表返回 1 }int LinkedListEmpty(LinkedList L){ //函数功能:判断链表是否为空参数:链表(linklist L) 链表为空时返回 0, 不为空返回 1 }void LinkedListTraverse(LinkedList L){ //函数功能:遍历链表,输出每一个节点的 elem 值参数:链表(linklist L) 通过循环逐个输出节点的 elem 值 }int LinkedListLength(LinkedList L){ //函数功能:返回链表的长度参数:链表(linklistL) 函数返回链表的长度 }LinkedList LinkedListGet(LinkedList L,int i){ //函数功能: 从链表中查找有无给定元素参数;链表(linklist L),给定元素 (int i) 如果链表中有给定元素(i)则返回 1,否则返回 0 }LinkedList LinkedListLocate(LinkedList L, DataType x){//函数功能: 从链表中查找给定元素的位置参数;链表(linklist L),给定元素(int i) 如果链表中有给定元素 i 则返回元素的位置, 没有则返回 0 }void LinkedListInsert(LinkedList &L,int i,DataType x)}void LinkedListDel(LinkedList &L,DataType x)i 个结点 }(二)、zhujiemian();cin>>a;do{switch(a){case 1:if(init(L)==1)cout<<"成功初始化! "<<endl;elsecout<<"初始化失败! "<<endl;break;case 2:if(makeempty(L)==1)cout<<"链表已清空! "<<endl;elsecout<<"链表清空失败! "<<endl;break;case 3:b=getlength(L);cout<<"链表的长度为: "<<b<<endl;break;case 4:if(isempty(L)==1)cout<<"链表不为空! "<<endl;elsecout<<"链表为空! "<<endl;break;case 5:if(isfull(L)==1)cout<<"链表不满! "<<endl;elsecout<<"链表已满! "<<endl;break;case 6:show(L);break;case 7:cout<<"输入您要查找的元素: ";cin>>b;if(find(L,b)==1)cout<<"链表中有该元素"<<b<<endl;elsecout<<"链表中没有您要查找的元素"<<b<<endl;break;case 8:cout<<"您要查找的元素为: "<<endl;cin>>b;if(location(L,b)==0)cout<<"没有您要查找的元素"<<b<<endl;elsecout<<"您查找的元素 "<<b<<"在第"<<location(L,b)<<"个位置。
链表实验报告总结doc

链表实验报告总结篇一:顺序表,链表总结实验报告实验报告实验目的:学生管理系统(顺序表)实验要求:1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序:#include#include#include#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 {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;klength;k++){w=k+1;printf("第%d位学生:",w);printf("%s %s%d\n",L->data[k].xh,L->data[k].xm,L->d ata[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;}else if((iL->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;ilength;i++){篇二:单链表的实验报告辽宁工程技术大学上机实验报告篇三:单链表实验报告实验一线性表基本操作的编程实现--线性表在链表存储下的主要操作实现班级:T523-1 姓名:王娟学号:33完成日期:XX.04.04 地点:5502学时:2学时一、需求分析【实验目的】通过本次实验,对课堂上线性表的知识进行巩固,进一步熟悉线性表的链接存储及相应的基本操作;并熟练掌握VC++ 6.0操作平台,学会调试程序,以及编写电子实验报告【实验要求】编写线性表的基本操作,有构造线性表,线性表的遍历,插入,删除,查找,求表长等基本功能,在此基础上能够加入DOS下的图形界面以及学会文件的操作等功能,为以后的学习打下基础。
数据结构顺序表链表试验报告

数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念,它用于组织和存储数据,以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构,它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较,以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异,并分析其时间复杂度和空间复杂度。
通过实验结果,可以对不同场景下选择合适的数据结构提供参考。
三、实验内容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。
链表实验报告

链表实验报告一、实验目的链表是一种常见的数据结构,本次实验的主要目的是深入理解链表的概念、原理和操作,通过实际编程实现链表的创建、插入、删除、遍历等基本操作,掌握链表在数据存储和处理中的应用,提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为 C 语言,开发工具为 Visual Studio Code。
三、实验原理链表是一种动态的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表的优点是可以灵活地进行插入和删除操作,不需要像数组那样移动大量的数据。
链表分为单向链表、双向链表和循环链表等。
单向链表只有一个指向下一个节点的指针,双向链表有指向前一个节点和后一个节点的指针,循环链表的尾节点指向头节点,形成一个环形结构。
四、实验步骤1、单向链表的创建定义链表节点结构体,包含数据域和指针域。
编写创建链表的函数,通过动态分配内存创建链表节点,并将节点连接起来。
2、单向链表的插入操作实现头部插入、尾部插入和中间插入的函数。
在插入时,需要处理指针的更新,确保链表的连接正确。
3、单向链表的删除操作编写删除指定节点的函数。
删除节点时,要释放被删除节点的内存,并更新相邻节点的指针。
4、单向链表的遍历实现遍历链表并打印节点数据的函数。
5、双向链表的创建与操作类似于单向链表,定义双向链表节点结构体,并实现创建、插入、删除和遍历的函数。
注意双向链表中指针的更新方式与单向链表的不同。
6、循环链表的创建与操作定义循环链表节点结构体,创建循环链表。
实现循环链表的插入、删除和遍历操作,处理好尾节点与头节点的连接。
五、实验结果与分析1、单向链表成功创建了单向链表,并能够正确进行头部、尾部和中间的插入操作。
删除操作也能准确删除指定节点,并释放内存。
遍历输出的结果与预期相符。
2、双向链表双向链表的创建和各种操作都能正常执行,指针的更新没有出现错误。
在双向链表中,插入和删除操作的效率相对单向链表有所提高,因为可以直接通过前向指针进行操作。
链表(单链表 双向循环)实验报告讲解

数据结构实验报告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.插入4.查找5.删除6.列表7.退出源程序:#include#include#include#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 {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;klength;k++){w=k+1;printf("第%d位学生:",w);printf("%s %s%d\n",L->data[k].xh,L->data[k].xm,L->d ata[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;else if((iL->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;ilength;i++){篇二:单链表的实验报告辽宁工程技术大学上机实验报告篇三:单链表实验报告实验一线性表基本操作的编程实现--线性表在链表存储下的主要操作实现班级:T523-1 姓名:王娟学号:33完成日期: 地点:5502学时:2学时一、需求分析【实验目的】通过本次实验,对课堂上线性表的知识进行巩固,进一步熟悉线性表的链接存储及相应的基本操作;并熟练掌握VC++ 6.0操作平台,学会调试程序,以及编写电子实验报告【实验要求】编写线性表的基本操作,有构造线性表,线性表的遍历,插入,删除,查找,求表长等基本功能,在此基础上能够加入DOS下的图形界面以及学会文件的操作等功能,为以后的学习打下基础。
链表的合并 实验报告

链表的合并实验报告一、实验目的本次实验的主要目的是深入理解链表的数据结构,并通过编程实现链表的合并操作,以提高对数据结构和算法的理解与应用能力。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
三、实验原理链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
在合并两个链表时,需要比较两个链表节点的值,将较小的值依次添加到新的合并链表中。
当其中一个链表遍历完后,将另一个链表剩余的节点直接添加到合并链表的末尾。
四、实验步骤1、定义链表节点类```pythonclass ListNode:def __init__(self, val=0, next=None):selfval = val```2、合并链表函数```pythondef mergeTwoLists(l1, l2):dummy = ListNode(0) curr = dummywhile l1 and l2:if l1val < l2val:currnext = l1l1 = l1nextelse:currnext = l2l2 = l2nextcurr = currnextif l1:currnext = l1if l2:return dummynext```3、测试函数```pythondef test_mergeTwoLists():构建测试链表 l1l1 = ListNode(1)l1next = ListNode(2)l1nextnext = ListNode(4)构建测试链表 l2l2 = ListNode(1)l2next = ListNode(3)l2nextnext = ListNode(4)merged_list = mergeTwoLists(l1, l2)打印合并后的链表while merged_list:print(merged_listval, end="")merged_list = merged_listnext```五、实验结果与分析运行测试函数,得到合并后的链表输出为:1 1 2 3 4 4 。
c课程设计链表实验报告

c课程设计链表实验报告一、教学目标本节课的教学目标是让学生掌握链表的基本概念和操作,包括链表的定义、节点的结构、链表的创建、插入、删除和遍历等操作。
通过本节课的学习,学生应该能够理解链表的工作原理,熟练使用链表进行数据存储和操作,并能够编写相应的程序实现链表功能。
具体来说,知识目标包括:1.了解链表的定义和特点;2.掌握链表的基本操作及其时间复杂度;3.理解链表在数据存储和处理中的应用场景。
技能目标包括:1.能够使用编程语言实现链表的创建、插入、删除和遍历等基本操作;2.能够分析链表程序的正确性和性能;3.能够运用链表解决实际问题,如实现一个简单的链表排序算法。
情感态度价值观目标包括:1.培养学生的逻辑思维能力和问题解决能力;2.激发学生对计算机科学和编程的兴趣;3.培养学生的团队合作意识和代码规范意识。
二、教学内容本节课的教学内容主要包括链表的基本概念和操作。
具体安排如下:1.链表的定义和特点:介绍链表的概念、节点结构以及链表的两种类型(单向链表和双向链表);2.链表的创建:讲解如何创建一个链表,包括初始化节点和链接节点的方法;3.链表的插入操作:介绍如何在链表中插入一个新节点,包括头插法和中插法的实现;4.链表的删除操作:讲解如何删除链表中的一个节点,包括头删法和中删法的实现;5.链表的遍历操作:介绍如何遍历链表,实现链表中各个节点的访问和打印;6.链表的应用场景:举例说明链表在实际编程中的应用,如链表排序算法。
三、教学方法为了达到本节课的教学目标,将采用以下教学方法:1.讲授法:讲解链表的基本概念和原理,引导学生理解链表的工作方式;2.案例分析法:通过分析典型链表程序,让学生掌握链表的操作方法和技巧;3.实验法:让学生动手编写链表程序,培养学生的实际编程能力和问题解决能力;4.讨论法:学生进行小组讨论,分享学习心得和编程经验,提高学生的团队合作意识。
四、教学资源为了支持本节课的教学内容和教学方法的实施,将准备以下教学资源:1.教材:《数据结构与算法》;2.参考书:《链表:原理与实现》;3.多媒体资料:PPT课件、链表操作视频教程;4.实验设备:计算机、编程环境。
链表的基本操作实验报告

链表的基本操作实验报告链表的基本操作实验报告引言:链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表相较于数组拥有更灵活的操作,能够动态地增删节点。
本实验旨在通过实际操作链表,加深对链表基本操作的理解和掌握。
实验目的:1. 理解链表的基本概念和结构;2. 学会链表的插入、删除和遍历操作;3. 掌握链表的相关算法。
实验过程:1. 创建链表首先,我们需要创建一个链表。
链表可以是单链表、双链表或循环链表,本次实验我们选择创建一个单链表。
创建链表的过程如下:(1)定义一个链表的节点结构,包含数据和指向下一个节点的指针;(2)创建头节点,并将头节点的指针指向NULL,表示链表为空。
2. 插入节点链表的插入操作可以在链表的任意位置插入节点。
我们可以选择在链表的头部、尾部或指定位置插入节点。
下面以在链表头部插入节点为例,介绍插入节点的过程:(1)创建一个新节点,设置新节点的数据;(2)将新节点的指针指向原头节点;(3)将头节点的指针指向新节点,完成插入操作。
3. 删除节点链表的删除操作可以删除链表中的任意节点。
同样,我们可以选择删除链表的头部、尾部或指定位置的节点。
以下是删除链表头部节点的步骤:(1)将头节点的指针指向下一个节点,跳过原头节点;(2)释放原头节点的内存空间。
4. 遍历链表链表的遍历操作用于访问链表中的每个节点。
通过遍历链表,我们可以获取链表中的所有数据或执行特定的操作。
链表的遍历操作如下:(1)从链表的头节点开始,依次访问每个节点;(2)对每个节点执行相应的操作,如打印节点的数据。
实验结果:通过以上实验过程,我们成功地创建了一个链表,并实现了链表的插入、删除和遍历操作。
链表的基本操作能够灵活地处理数据,适用于各种场景。
链表的插入和删除操作可以在O(1)时间内完成,相较于数组的插入和删除操作具有更高的效率。
实验总结:链表作为一种常见的数据结构,具有灵活性和高效性的特点。
数据结构链表的插入和删除实验报告范文

数据结构链表的插入和删除实验报告范文实验报告及详细设计第三次实验报告——单链表的建链表,插入结点,删除结点运算一需求分析1、在演示程序中,浮现的元素以数字浮现2、演示程序在计算机终端上,用户在键盘上输入演示程序中规定的运算命令,相应的输入数据和运算结果显示在终端上3、程序执行的命令包括如下:(1)定义结构体(2)链表的初始化及创建(3)元素的插入(4)元素的删除(5)链表的打印结果4、测试数据二概要设计1、可能需要用到有序表的抽象数据类型定义:ADTLit{数据对象:D={ai|ai∈ElemL,i=1,2,...,n,n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2,...,n}基本操作:CreateLit_L(&L,n)操作结果:逆序位输入 n 个元素的值,建立带头结点的单链线性表 L LitInert(L,i,e)初始条件:线性表 L 存在操作结果:在 L 中第 i 个位置之前插入新的数据元素 eLitDelete (&L,i)初始条件:线性表 L 存在且非空实验报告及详细设计操作结果:删除 L 的第 i 个元素,并用 e 返回其值, L 的长度减 1 }ADTLit;2、程序包含的主要模块:(1)已给定的函数库:(2)单链表结构体:(3)链表初始化及创建:(4)主程序:(5)操模块作(插入、删除、输出函数):三详细设计结构体typedeftructLNode//结点类型{intdata;//数值域tructLNode 某 ne 某 t;//指针域}LNode,某 Linklit;LinklitInitlit_L(intn)//创建带头结点的单链表{LinklitL;LinklitP;inti;实验报告及详细设计L=(Linklit)malloc(izeof(LNode));L->ne 某 t=NULL;/某先建立一个带头结点的单链表某请输入%d个数据for(i=n;i>0;--i){P=(Linklit)malloc(izeof(LNode));/某生成新结点某/某输入元素值某/P->ne 某 t=L->ne 某 t;/某插入到表头某/L->ne 某 t=P;}returnL;}插入函数LinklitLitInert_L(LinklitL,inti,inte)//单链表的插入{LinklitP,S;intj;P=L;j=0;while(P&&j<i-1)实验报告及详细设计{P=P->ne 某 t;++j;}//寻觅第 i-1 个节点if(!P| |j>i-1)错S=(Linklit)malloc(izeof(LNode));//生成新节点 S->data=e;S->ne 某 t=P->ne 某 t;//插入到 S 中P->ne 某 t=S;returnP;}删除函数LinklitLitDelete_L(LinklitL,inti)//单链表的删除{ LinklitP,S;intj;P=L;j=0;while(P->ne 某 t&&j<i-1){P=P->ne 某 t;实验报告及详细设计++j;}//寻觅第个节点,并令 P 指向其前驱if(!(P->ne 某 t) | |j>i-1)错S=P->ne 某 t;P->ne 某 t=S->ne 某 t;//删除并释放节点free(S);returnP;}输出函数voidprintlit_L(LinklitL)//输出单链表{while(L->ne 某 t!=NULL){L=L->ne 某 t;}}主函数实验报告及详细设计intmain(){LinklitL;inti,choice,n,e;请输入链表元素个数L=Initlit_L(n);请输入操作元素的位置请选择执行语句,选择输入 1 执行插入操作或者选择输入 2 执行删除操作witch(choice){cae1:{请输入插入元素的值:L=LitInert_L(L,i,e);插入后的链表为:printlit_L(L);};break;实验报告及详细设计cae2:{L=LitDelete_L(L,i);删除后的链表为printlit_L(L);};break;}}库函数某 Bae.h(程序名)某/#include<tring.h>#include<ctype.h>#include<malloc.h>/某 malloc()等某/#include<limit.h>/某 INT_MA 某等某/#include<tdio.h>/某 EOF(=^Z 或者 F6),NULL 某/ #include<tdlib.h>/某 atoi()某/#include<io.h>/某 eof()某/#include<math.h>/某 floor(),ceil(),ab()某/#include<proce.h>/某 e 某 it()某//某函数结果状态代码某/#defineTRUE1#defineFALSE0实验报告及详细设计#defineOK1#defineERROR0#defineINFEASIBLE-1/某#defineOVERFLOW-2 因为在 math.h 中已定义 OVERFLOW 的值为 3, 故去掉此行某/typedefintStatu;/某 Statu 是函数的类型,其值是函数结果状态代码,如 OK 等某/typedefintBoolean;/某 Boolean 是布尔类型,其值是 TRUE 或者FALSE 四调试分析:操作函数中的指针变换错用了数组中的 L++;应该为 L=L->ne 某 t;五用户手册:看提示内容六测试结果1)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为2,执行 choice=1,插入值为 4,操作后的结果为: 34212)输入 n 的个数为 4,链表的初始赋值为: 1234,操作数 i 的位置为 5,执行 choice=1,插入值为 5,操作后的结果为:“没有返回值”3)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为 0,执行 choice=1,插入值为 4,操作后的结果为:“没有返回值”4)输入 n的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为 2,执行choice=2,操作后的结果为: 31实验报告及详细设计5)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为4,执行 choice=2,操作后的结果为:“没有返回的值”6)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为 0,执行 choice=2,操作后的结果为:“没有返回的值”。
链表实验总结

链表实验总结链表这东西啊,我一开始接触的时候,就感觉像是走进了一个迷宫。
我瞅着那些个节点啊,就像瞅着一群调皮捣蛋的小鬼,每个都有自己的主意,互相连着又好像随时要散开。
我记得那时候在实验室里,灯光昏昏暗暗的,周围的同学们都在闷头捣鼓自己的代码。
我呢,对着电脑屏幕上那一串链表相关的代码,眼睛瞪得像铜铃。
我旁边的小李,那家伙,头发乱得像个鸟窝,他凑过来瞅了一眼我的屏幕,说:“你这链表建得咋跟个歪脖子树似的。
”我一听就不乐意了,“啥歪脖子树,这是我的独特创意。
”可心里也知道,这链表确实被我弄得乱七八糟。
我就开始重新捋思路,想着每个节点就像一个小房子,里面住着数据这个小居民,指针呢就是连接这些小房子的小路。
我就这么一点点地构建,手指在键盘上敲得噼里啪啦的,就像在演奏一场奇特的音乐会。
有时候敲错了一个字母,程序就报错,那感觉就像正唱着歌突然被人掐住了脖子,别提多难受了。
我又去看那些参考资料,那书上的字啊,密密麻麻的,看着就头疼。
可没办法啊,我得把这链表搞明白。
我一边看一边在心里嘟囔,“这链表啊,你就不能简单点吗?像1 + 1 = 2那么简单多好。
”我试着按照书上的示例重新写代码,每写一行就感觉离成功近了一步,可有时候还是会掉进陷阱里。
有一次,我好不容易觉得链表整得差不多了,运行起来却发现数据都乱套了。
我当时那个气啊,对着屏幕就想骂街。
我把旁边的小王叫过来,他那脸长得像个大烧饼,眼睛小小的。
他看了看我的代码,笑了笑说:“你这指针指错地方了呀,就像火车开到岔道上去了。
”我恍然大悟,赶紧修改。
在这个过程中,我就像在跟链表这个调皮的家伙斗智斗勇。
有时候我觉得我已经把它征服了,可它又突然给我来个下马威。
但慢慢的,我也摸出了些门道。
链表虽然麻烦,但只要你用心去对待每个节点,每个指针,就像对待自己的孩子一样,它也会乖乖听话。
现在再看链表,虽然还是有点小复杂,但我已经不再害怕它了,反而觉得它还挺有趣的呢。
链表-实验报告

实验2 链表实验概述:一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现,包括创建、插入、删除、查找、以及合并等操作。
二、实验要求掌握链表存储方式,熟悉链式存储结构。
三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。
步骤:输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5实验结果如图:四、实验环境(使用的软件和设备)(1)实习器材:多媒体计算机。
(2)实习地点:校内多媒体机房。
(3)实习软件: Win-TC实验内容:【实验过程】(实验步骤、记录、数据、分析)实验过程(提示)输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5【结果实验记录】(图形或图像)1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。
链表的基本操作实验报告

《数据结构》实验报告学号1445203105 姓名王胜博班级软件5班成绩实验名称实验三链表的基本操作是否原创是一、实验要求编程实现链表下教材第二章定义的线性表的基本操作,最好用菜单形式对应各个操作,使其编程一个完整的小软件。
二、实验目的通过该实验,深入理解链表的逻辑结构、物理结构等概念,掌握链表基本操作的编程实现,熟练掌握C语言中指针的操作。
和实验2对比,掌握线性结构两种不同存储方式的区别。
三、设计思想用函数执行各个功能,随机插入元素四、主要源代码#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node, *LinkList;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));if(!(*L))printf("存储分配失败\n");(*L)->next=NULL;}void DestroyList(LinkList L){LinkList p;while(L){p=L->next;free(L);L=p;}}int ListLength(LinkList L){LinkList p;int i=0;p=L->next;while(p){i++;p=p->next;}return i;}int GetElem(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}e=p->data;return e;}int GetElemLo(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p->data!=i&&j<=ListLength(L)){p=p->next;++j;}e=j;return e;}void FindPre(LinkList L,int x){LinkList p;p=L;if(p->next->data==x){printf("第一个元素没有前驱\n");}else{while(p->next){if(p->next->data==x){printf("%d的前驱结点是:%d\n",x,p->data);break;}else{p=p->next;}}}}void FindNext(LinkList L,int x){LinkList p;p=L->next;while(p){if(p->data==x){printf("%d的后继结点是:%d\n",x,p->next->data);break;}else{p=p->next;}if(p->next==NULL){printf("最后一个元素没有后继\n");break;}}}void LinkInset_L(LinkList &L,int i,ElemType e){ LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("i小于1或者i大于表长加1\n");LinkList s;s=(LinkList)malloc(sizeof (Node));s->data=e;s->next=p->next;p->next=s;}void ListDelete_L(LinkList &L,int i,ElemType &e){ LinkList p,q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!p->next ||j>i-1)printf("删除位置不合理\n");q=p->next;p->next=q->next;e=q->data;free(q);printf("已删除的元素是:%d\n",e);}void visit(ElemType e){printf("%d,",e);}void ListTraverse(LinkList L){LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");}void CreatListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node));r=*L;for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node));p->data=rand()%100+1;r->next=p;r=p;}r->next=NULL;}int main(){LinkList L;int opp;printf("可执行的操作有:\n");printf("1.初始化或重置链表\n");printf("2.随机插入元素\n");printf("3.显示链表中数据元素个数\n");printf("4.输出所输入的链表元素\n");printf("5.所指位序的元素值\n");printf("6.链表已存在元素的位序\n");printf("7.请输入元素,求直接前驱\n");printf("8.请输入元素,求直接后继\n");printf("9.在第i个位置插入元素\n");printf("10.删除第i个元素\n");printf("11.销毁链表\n");printf("12.退出\n");printf("\n");printf("请输入你的选择:\n");do{scanf("%d",&opp);switch(opp){case 1:{InitList(&L);printf("链表已初始化\n");printf("下一步操作:");break;}case 2:{int n;printf("输入插入元素个数:");scanf("%d",&n);CreatListTail(&L,n);printf("下一步操作:");break;}case 3:{printf("链表中元素的个数是:%d\n",ListLength(L));printf("下一步操作:");break;}case 4:{ListTraverse(L);printf("下一步操作:");break;}case 5:{int m,e;printf("输入要取元素的位置:");scanf("%d",&m);if(m>ListLength(L)){printf("输入有误\n");}else{GetElem(L,m,e);printf("该元素是:%d\n",e);}printf("下一步操作:");break;}case 6:{int i,e;printf("输入要取的元素:");scanf("%d",&i);GetElemLo(L,i,e);printf("该元素的位置是:%d\n",e);printf("下一步操作:");break;}case 7:{int x;printf("要求哪个元素的前驱?");scanf("%d",&x);FindPre(L,x);printf("下一步操作:");break;}case 8:{int x;printf("要求哪个元素的后继?");scanf("%d",&x);FindNext(L,x);printf("下一步操作:");break;}case 9:{int i,e;printf("在哪个位置插入元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{printf("插入的新元素是:");scanf("%d",&e);LinkInset_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 10:{int i,e;printf("要删除哪个位置的元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{ListDelete_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 11:{DestroyList(L);printf("链表已销毁!\n");printf("下一步操作:");break;}case 12:{printf("谢谢使用\n");break;}default:{printf("输入错误,请重新输入\n");break;}}}while(opp!=12);return 0;}五、调试与测试数据六、实验总结。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
创建一个空的单链表,实现对单链表的查找,插入,删除的功能
三、源程序及注释:
#defi ne OK1
#defi ne ERROR0
#defi ne INFEASIBLE-1
#defi ne OVERFLOW-2
#defi ne TRUE1
#defi ne FALSE0
int i;
Lin kList p,q;
ET str[20],c;
p=(L in kList)malloc(sizeof(LNode));
p-> next=NULL;
*L = q = p;
prin tf("Please in put the data:");
for (i=n ;i>0;i__) {
p=(L in kList)malloc(sizeof(LNode));
prin tf("Please in put the nu mber of the node:"); scan f("%d",&n);
CreatList(L, n);
}
/* Get the value of eleme nt I; */
int GetElem(LinkList L,int i,ET *e) {
贝叽则显示“找不到”。
3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插
入在对应位置上,输出单链表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置, 输出单链表所有结点值, 观察输出结果。
5.将单链表中值重复的结点删除,使所得的结果表中个结点值均不相同,输出单链表所有
p=L->n ext;
while (p) {
prin tf("%c -> ",p->data);
p = p_>n ext;
}
prin tf("NULL\n”);
}
/*Creat lin klist from head no de. */
void CreatList( Lin kList *L,i nt n){
结点值,观察输出结果。
6.删除其中所有数据值为偶数的结点,输出单链表所有结点值,观察输出结果。
7.(★)将单链表分解成两个单链表A和B,使A链表中含有原链表中序号为奇数的元
素,而B链表中含有原链表中序号为偶数的元素,且保持原来的相对顺序,分别输出 单链表A和单链表B的所有结点值,观察输出结果。
、程序设计的基本思想,原理和算法描述:
/* Add your own codes. */
}
/*Delete the eleme nt I */
int ListDelete(LinkList *L,int i,ET *e)
{
/* Add your own codes. */
}
int In sert(Li nkList *L) {
int i,flag;
#defi ne List」ni t_Size10
#defi ne ListI ncreme nt2
typedef char ET;
typedef ET * Ep;
typedef int Status;
typedef struct LNode{
ET data;
struct LNode *n ext;
return flag;
}
Status Delete(L in kList *L) {
int i,flag;
ET e;
prin tf("Please in put the nu mber:"); scan f("%d",&i);
flag = ListDelete(L,i, &e);
printf("Deleted element is %c\n",e); return flag;
}/*Biblioteka dd the Lb after the La. */
}LNode, *Li nkList;
/*Lin kList La,Lb,Lc;*/
#i nclude "stdio.h"
#i nclude "alloc.h"
/*Display the linklist's elements. */
void prin tlk(Li nkList L) {
Lin kList p;
《数据结构》实验报告二
系别:嵌入式系统工程系
学号:1116040031
日期:2012年4月9日_
、上机实验的问题和要求:
单链表的查找、插入与删除。设计算法,实现线性结构上的单链表的产生以及元素的查
找、插入与删除。具体实现要求:
1.从键盘输入10个字符,产生不带表头的单链表,并输入结点值。
2.从键盘输入1个字符,在单链表中查找该结点的位置。若找到,则显示“找到了”;否
c = getche(); /*sca nf("%c",&c);*/
prin tf("\n\n");
p->data = c;
p_>next = q_>n ext;
q_>next = p;
}
}
/*Init the linklist. */
void Ini t(Li nkList *L) {
int n;
int j=1;
Lin kList p;
p=L->n ext;
while(p&&j<i){
p=p->n ext;
++j;
}
if(!p||j>i) return TRUE;
*e=p_>data;
return FALSE;
}
/*ln sert a eleme nt after I*/
int ListInsert(LinkList *L,int i,ET e) {
ET data;
prin tf("Please in put the positi on: ”);scan f("%d",&i);
prin tf("Please in put the data:");
data = getche(); /*sca nf("%c", &data);*/
flag = ListI nsert(L,i,data);
}
/*Find the eleme nt's positi on. */
int LocateElem(L in kList L,ET e) {
int i=0;
Lin kList p;
p = L_>n ext;
while (p) {
i++;
if (p->data == e) retur n i;
}
return 0;