链表的基本操作与实现
单链表的基本操作实验报告
湖南第一师范学院信息科学与工程系实验报告课程名称：数据结构与算法成绩评定：实验项目名称：单链表的基本操作指导教师：学生姓名：沈丽桃学号： 10403080118 专业班级： 10教育技术实验项目类型：验证实验地点：科B305 实验时间： 2011 年 10 月20 日一、实验目的与要求：实验目的：实现线性链表的创建、查找、插入、删除与输出。
基本原理：单链表的基本操作二、实验环境：（硬件环境、软件环境）1.硬件环境：奔ⅣPC。
2.软件环境：Windows XP 操作系统，TC2.0或VC＋＋。
三、实验内容：（原理、操作步骤、程序代码等）#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct celltype{int element;struct celltype*next;};typedef int position;void main(){struct celltype*head,*p;int x,choice;void INSERT(int x,struct celltype*p);void LOCATE(int x,struct celltype*p);void DELETE(int x,struct celltype*p);p=(struct celltype*)malloc(sizeof(struct celltype));head=p;p->element=0;p->next=NULL;printf(“Please option:1:Insert 2:Locate 3:Delete\n”);printf(“Please choose:”);scanf(“%d”,&choice);switch(choice)case 1:printf(“Please input a node:”);scanf(“%d”,&x);p=head;INSERT(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->element);printf(“\n”);break;case 2:printf(“Please input the data you want to locate:”); scanf(“%d”,&x);p=head;LOCATE(x,p);break;case 3:printf(“Please input the data you want to delete:”); scanf(“%d”,&x);DELETE(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->next);printf(“\n”);break;}void INSERT(int x,struct celltype*p){struct celltype*t,*q;q=(struct celltype*)malloc(sizeof(struct celltype)); q->next=x;while((x>p->element)&&(p!=NULL)){t=p;p=p->next;}if((x>p->element)&&(p->next!=NULL)){p->next=q;q->next=NULL;}else{q->next=p;t->next=q;}}void LOCATE(int x,struct celltype*p){while(p->next!=NULL)if(p->next->element==x)printf(“the number %d is in %d\n”,x,p);else printf(“the number not exist!\n”);}void DELETE(int x,struct celltype*p){while((p->element!=x)&&(p->next!=NULL)){t=p;p=p->next;}if(p->element==x)t->next=p->next}error C2018:unknown character ’Oxal’error C2065:’Please’:undeclared identifiererror C4024:’printf’:different types for formal and actual parameter 1error C4047:’function’:’const*differs in levers of indirection from ’int’error C2146:syntaxerror:missing’)’before identifier’option’error C2017:illegal escape sequenceerror C2059:syntax error:’)’error C2143:syntax error:missing’)’before’%’出现了很多错误，主要是因为printf里的一对双引号不是英文状态下的。
单链表的基本操作
10）调用头插法的函数，分别输入10,20，分别回车：
11）调用尾插法的函数，分别输入30,40
12）查找单链表的第四个元素：
13）主函数中传入参数，删除单链表的第一个结点：
14）主函数传入参数，删除第0个未位置的元素，程序报错：
15）最后，输出单链表中的元素：
return 0;
}
6）编译，连接，运行源代码：
7）输入8，回车，并输入8个数，用空格分隔开，根据输出信息，可以看出，链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式，指针域总是指向下一个结
点（结构体）的地址，因此，在内存中的地址空间可以是不连续的，操作比顺序存储更加的方便
2.单链表使用时，需要用malloc函数申请地址空间，最后，删除元
素时，使用free函数释放空间。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：掌握单链表的基本操作，学会使用单链表实现各种算法。
实验内容：实现单链表的基本操作，包括创建、插入、删除、访问等。
利用单链表完成以下算法：- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第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指向的节点即为要删除的节点。
实验三四 链表的实现和应用
江南大学物联网工程学院上机报告课程名称 班 级 数据结构 上机名称 姓 名 链表的实现和应 用 上机日期 学 号 2016.3.11 上机报告要求 1．上机名称 2．上机要求 3．上机环境 4．程序清单（写明运行结果） 5．上机体会1．上机名称链表的实现和应用2．上机要求⑴定义线性表的链式存储表示； ⑵基于所设计的存储结构实现线性表的基本操作； ⑶编写一个主程序对所实现的线性表进行测试； ⑷线性表的应用：①设线性表 L1和 L2分别代表集合 A 和 B，试设计算法求 A 和 B 的并集 C，并用线 性表 L3代表集合 C；②设线性表 L1和 L2中的数据元素为整数，且均已按值非递减有序排列，试 设计算法对 L1和 L2进行合并，用线性表 L3保存合并结果，要求 L3中的数据元素也按值非递减 有序排列。
⑸设计一个一元多项式计算器，要求能够：①输入并建立多项式；②输出多项式；③执行两个多项式 相加；④执行两个多项式相减；⑤（选做）执行两个多项式相乘。
3．上机环境Visual C++ 6.04．程序清单（写明运行结果）（1） #include<stdio.h> #include<stdlib.h> typedef int datatype; typedef struct node { datatype data; struct node *next; }LinkList; LinkList *CREATLISTF(LinkList *L,int n) { intnum,i; LinkList *head,*s,*r; head=L; r=head; head->next=NULL;printf("请输入集合中的元素（由小到大） ：\n"); for(i=0;i<n;i++) { scanf("%d",&num); s=(LinkList*)malloc(sizeof(LinkList)); s->data=num; r->next=s; r=s; } r->next=NULL; return head; } LinkList *merge(LinkList *L1,LinkList *L2) { LinkList *L3,*pa,*pb1,*pb2,*pc; L3=(LinkList*)malloc(sizeof(LinkList)); L3->next=NULL; pa=L1->next; pb1=pb2=L2->next; pc=L3; while(pa && pb1) if(pa->data<pb1->data) { pc->next=pa;pc=pa; pa=pa->next; } else if(pa->data>pb1->data) { pc->next=pb1;pc=pb1; pb1=pb1->next; } else { pc->next=pa; pc=pa;pa=pa->next;pb1=pb2=pb1->next; } if(pa)pc->next=pa; else pc->next=pb1; return(L3); } void display(LinkList *L) { LinkList *head; head=L->next;do { printf("%d\t",head->data); head=head->next; }while(head!=NULL); } void main() { intan,bn; LinkList *L1,*L2,*L3; L1=(LinkList*)malloc(sizeof(LinkList)); L2=(LinkList*)malloc(sizeof(LinkList)); printf("\n 集合 A 中元素的个数：\n"); scanf("%d",&an); *L1=*CREATLISTF(L1,an); printf("集合 A 的元素为：\n"); display(L1); printf("\n 集合 B 中元素的个数:\n"); scanf("%d",&bn); *L2=*CREATLISTF(L2,bn); printf("集合 B 的元素为:\n"); display(L2); L3=merge(L1,L2); printf("\n 集合 A 与集合 B 的并集为:\n"); display(L3); }（2） #include<stdio.h> #include<stdlib.h> struct node { intexp; float coef; struct node *next; }; typedef struct node ListNode; ListNode *createpoly() { ListNode *h=NULL,*p,*q=NULL; int e; float c; printf("请输入系数和指数:"); scanf("%f,%d",&c,&e); while(e!=0||c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(h==NULL) h=p; else q->next=p; q=p; printf("请输入系数和指数:"); scanf("%f,%d",&c,&e); } return h; } void disppoly(ListNode *h) { ListNode *p; p=h; while(p!=NULL) { if(p->exp==0) printf("%.2f",p->coef); else printf("%fx^%d",p->coef,p->exp); p=p->next;if(p!=NULL) printf("+"); } printf("\n"); } ListNode *addpoly(ListNode *h1,ListNode *h2) { ListNode *p,*r=NULL,*s1,*s2,*s=NULL; float c; int e; s1=h1; s2=h2; while(s1!=NULL&&s2!=NULL) { if(s1->exp==s2->exp) { c=s1->coef+s2->coef; e=s1->exp; s1=s1->next; s2=s2->next; } else if(s1->exp>s2->exp) { c=s1->coef; e=s1->exp; s1=s1->next; } else { c=s2->coef; e=s2->exp; s2=s2->next; } if(c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(s==NULL) s=p; else r->next=p; r=p;} } while(s1!=NULL) { c=s1->coef; e=s1->exp; s1=s1->next; if(c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(s==NULL) s=p; else r->next=p; r=p; } } while(s2!=NULL) { c=s2->coef; e=s2->exp; s2=s2->next; if(c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(s==NULL) s=p; else r->next=p; r=p; } } return s; } void deletepoly(ListNode *h) { ListNode *p,*r=h; while(r!=NULL){ p=r->next; free(r); r=p; } } void main() { ListNode *head1,*head2,*head; printf("第一个多项式为:\n"); head1=createpoly(); printf("第二个多项式为:\n"); head2=createpoly(); printf("将两个多项式相加后得:\n"); head=addpoly(head1,head2); disppoly(head); deletepoly(head); }5．上机体会并集的表示有两种方法，顺序结构和链式结构，首先先要搞清楚这两者的区别，然后再加以编写，改进程 序。
数据结构-单链表基本操作实现（含全部代码）
数据结构-单链表基本操作实现（含全部代码）今天是单链表的实现，主要实现函数如下：InitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。
最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数：单链表L，元素e 功能：查找第⼀个等于e的元素，返回指针时间复杂度O(n)代码：/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。
实验1顺序表和链表基本操作(学生)
实验一线性表运算的实现班级学号姓名一、实验预备知识1．复习C中函数的相关内容。
2．复习如何用主函数将多个函数连在一起构成一个C完整程序。
3．复习多文件结构。
二、实验目的1．掌握线性表的顺序和链式存储结构2．熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3．熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1．编写初始化并创建线性表和输出线性表的算法。
2．编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。
3．编写有序表的插入和删除运算算法。
4．编写一个主函数，将上面函数连在一起，构成一个完整的程序。
5．将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。
四、实验内容顺序表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．初始化并建立顺序表。
（开辟的存储空间大小为8）3．编写顺序表输出算法。
4．依次插入3，21，15三个数，分别插入在第4，6和2位置，每插入一次都要输出一次顺序表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次顺序表。
6．编写一个排序算法，对线性表中元素从小到大排列。
7．向有序表分别插入20和50，插入后表仍然有序。
（修改开辟的存储空间大小为15）单链表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．建立一个带表头结点的单链表（前插入法和尾插入法都可以）。
3．编写单链表输出算法。
4．依次插入3，21，15三个数，分别插入在第4，6和12位置，每插入一次都要输出一次单链表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次单链表。
6．编写一个排序算法，对线性表中元素从小到大排列。
7．分别删除值为25和42的元素，删除后表仍然有序。
五、实验结果给出程序清单及输入/输出结果六、总结1．实验过程中遇到的问题及解决方法2．收获北华航天工业学院《数据结构》课程实验报告实验题目：作者所在系部：作者所在专业：作者所在班级：作者学号：作者姓名：任课教师姓名：完成时间：北华航天工业学院教务处制一、实验目的1 掌握线性表的顺序和链式存储结构；2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算；3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算。
数据结构单链表实验报告
数据结构单链表实验报告范本：数据结构单链表实验报告一、引言本实验旨在掌握数据结构中单链表的基本概念、操作和应用。
通过实际操作，理解单链表的结构与实现，提高数据结构的编程能力和问题解决能力。
二、实验目的1. 理解单链表的概念和特点；2. 掌握单链表的基本操作，包括插入、删除、遍历；3. 学会使用单链表解决实际问题。
三、实验内容1. 单链表的定义和结构设计；2. 单链表的基本操作的实现，包括插入节点、删除节点、遍历；3. 针对具体的问题，设计相应的单链表操作。
四、实验步骤1. 单链表的定义和结构设计：（1）定义单链表的结构体，包含数据域和指针域；（2）实现单链表的初始化函数；（3）实现单链表的销毁函数。
2. 单链表的基本操作的实现：（1）实现单链表的插入节点操作；（2）实现单链表的删除节点操作；（3）实现单链表的遍历操作。
3. 针对具体问题的单链表操作：（1）根据具体需求，设计并实现相应的操作函数；（2）利用单链表解决具体问题。
五、实验结果与分析1. 在实验过程中，成功实现了单链表的定义和结构设计，包括数据域和指针域的正确设置。
2. 实验中实现了插入节点、删除节点和遍历等基本操作。
3. 针对具体问题，通过单链表操作解决了相应的问题。
六、实验总结通过本次实验，加深了对单链表的理解和掌握。
掌握了单链表的基本操作和应用实现，提高了数据结构的编程能力和问题解决能力。
附件：1. 本文所涉及的代码文件；2. 实验过程中所用到的数据文件。
法律名词及注释：1. 数据结构：指的是一组数据的表示方法和相应的操作。
在计算机科学中，数据结构是计算机中存储、组织数据的方式。
2. 单链表：是一种链式存储结构，每个节点包含数据域和指针域。
数据域用于存储数据，指针域用于指向下一个节点。
实验二 链表操作实现
实验二链表操作实现实验日期：2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现；2. 以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点；3. 掌握线性表的链式存储结构的定义和基本操作的实现；4. 通过本实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用）。
实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。
（1）链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;（2）带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp，其代码如下所示，理解LinkList类型和基本运算函数后回答下列问题。
#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题：（1）由单链表结点类型定义可知，该链表结点类型名为 LinkNode ，结点的指针类型为 LinkList ，向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是： p=(LinkList)malloc(sizeof(LinkNode)); 。
实验二：单链表基本运算实现
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");
实验二 单链表基本操作
实验二单链表基本操作一实验目的1.学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二实验要求1．预习C语言中结构体的定义与基本操作方法。
2．对单链表的每个基本操作用单独的函数实现。
3．编写完整程序完成下面的实验内容并上机运行。
4．整理并上交实验报告。
三实验内容1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。
合并思想是：程序需要3个指针：pa、pb、pc，其中pa，pb分别指向La表与Lb表中当前待比较插入的结点，pc 指向Lc表中当前最后一个结点。
依次扫描La和Lb中的元素，比较当前元素的值，将较小者链接到*pc 之后，如此重复直到La或Lb结束为止，再将另一个链表余下的内容链接到pc所指的结点之后。
3．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。
（即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，如此等等。
）四思考与提高1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素，请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素，请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus 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) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。
数据结构链表的基本操作
数据结构链表的基本操作一、引言链表是计算机科学中的一种数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表可以用于实现栈、队列和其他数据结构。
本文将详细介绍链表的基本操作。
二、链表的基本概念1. 节点：链表中的每个元素称为节点，它包含两部分：数据和指向下一个节点的指针。
2. 头结点：链表中第一个节点称为头结点，它不包含实际数据，只有指向第一个真正节点的指针。
3. 尾节点：链表中最后一个节点称为尾节点，它的指针为空。
4. 空链表：不包含任何元素的链表称为空链表。
三、链表的基本操作1. 创建链表创建一个空链表很简单，只需要让头结点指针为空即可。
如果需要创建带有多个元素的非空链表，则需要依次创建每个节点，并将前一个节点的指针指向当前节点。
2. 插入元素在插入元素时，需要先找到要插入位置前面的那个节点。
然后新建一个要插入的节点，并将其指针指向原来位置上后面那个节点。
最后将前面那个节点的指针改为新建立的节点。
3. 删除元素在删除元素时，需要先找到要删除的那个节点。
然后将前一个节点的指针指向后一个节点，从而跳过要删除的那个节点。
最后释放要删除的节点。
4. 遍历链表遍历链表是指依次访问链表中每个元素。
可以使用循环结构来实现遍历操作。
从头结点开始，依次访问每个节点，并将其数据输出即可。
5. 查找元素查找元素时，需要从头结点开始依次遍历每个节点，直到找到目标元素或者遍历完整个链表为止。
6. 反转链表反转链表是指将原来的链表顺序倒置。
可以使用三个指针分别表示当前节点、前一个节点和后一个节点，依次修改它们之间的指针即可实现反转操作。
四、链表的应用举例1. 栈和队列：栈和队列都可以用链表来实现。
栈是一种先进后出（FILO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。
2. 链式存储文件系统：文件系统中通常采用基于树或者基于哈希表的存储方式。
但是在某些情况下，也可以采用基于链式存储方式来实现文件系统。
数据结构实验报告单链表
数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的1.掌握单链表的基本概念和原理。
2.了解单链表在计算机科学中的应用。
3.掌握单链表的基本操作，如插入、删除、遍历等。
4.通过实验，加深对理论知识的理解，提高编程能力。
二、实验内容1.实验原理：单链表是一种线性数据结构，由一系列节点组成，每个节点包含数据域和指针域。
其中，指针域指向下一个节点，最后一个节点的指针域指向空。
单链表的主要操作包括插入、删除、遍历等。
2.实验步骤：（1）创建一个单链表。
（2）实现插入操作，即在链表的末尾插入一个新节点。
（3）实现删除操作，即删除链表中的一个指定节点。
（4）实现遍历操作，即输出链表中所有节点的数据。
3.实验代码：下面是使用Python语言实现的单链表及其基本操作的示例代码。
class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果：通过运行上述代码，我们可以看到单链表的基本操作得到了实现。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。
（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。
（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。
数据结构实验报告之链表顺序表的操作
数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算：初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计⼀个主程序完成如下功能：（1）初始化顺序表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出顺序表L；（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出顺序表L；（9）删除L的第2个元素，之后输出顺序表L；（10）销毁顺序表L。
2、编写程序实现单链表的各种基本运算：初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计⼀个主程序完成如下功能：（1）初始化单链表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出单链表L；（4）输出单链表L的长度；（5）判断单链表L是否为空；（6）输出单链表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出单链表L；（9）删除L的第2个元素，之后输出单链表L；（10）销毁单链表L。
1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满，增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。
VC++程序设计链表与链表的基本操作
VC++程序设计 链表与链表的 基本操作
简单链表
链表是一种动态地进行存储分配的结构。最简单的链表称 为单向链表，如图所示： Head
初始 p1=head;
$7.7.4 对链表的插入操作
设已有的链表中各结点的成员是按学号由小到大顺序排列的。
p1
head p2
11041 89
11043 90
11047 85 NULL
p0
89102
初始 p1=p2=head; p0=&stud;
p1
head
p2 p0
11041 89 89102
11043 90
1249
1249
A 1356
1356
B 1475
1475
C 1021
1021
D NULL
特点： 1。头指针变量head, 它存放一个地址，用于指向一个元素。 链表中的一个元素称为结点。 2。每个结点至少应包含两个部分：一为用户需要的实际数据 二为下一个结点的地址。 3。“表尾” 的地址部分放一个“Null”（表示“空地址”） 表示链表的最后一个元素，该元素不再指向其它元素。
//插入结点的函数insert如下：
student *insert(student *head, student *stud) { student *p0,*p1,*p2; p1=head; p0=stud; if(head==Null) //原为空链表 { head=p0; p0->next=Null; } else while((p0->num > p1->num)&&(p1->next != Null)) { //查找插入位置 p2=p1; p1=p1->next; };
单向链表基本操作的递归实现
单向链表基本操作的递归实现这几天正在复习一些基本的算法和实现，今天看了看递归的基本原理，发现自己对递归还不是特别清楚，特别是不清楚递归的思想，不能很准确的把握先分解成小事件，在合并的思想，其实也是数学归纳法的程序体现，其实数学归纳法是一种强大的方法，记得高中的时候最喜欢做的题目就是数学归纳方面的证明，现在想过来好多问题我不能采用这种方式思考，可见知识真的是有联系的，只是我们没有找到联系的方式而已。
为了熟悉递归的思想，我尝试了采用递归的方式实现单向链表的基本操作。
单向的链表是C语言课程中接触到的中比较复杂的数据结构，但是他确实其他数据结构的基础，在一般情况下都是采用迭代的形式实现，迭代的形式相比递归要节省时间和空间，但是代码相对来说要复杂，递归往往只是简单的几句代码，我主要是为了熟悉迭代，并不在性能上进行分析。
基本的实现如下所示：#include;#include;typedef struct listnode{int val;struct listnode *next;}List;/*统计节点个数*/int count_listnode(List *head) {static int count = 0;if(NULL != head){count += 1;if(head->;next != NULL){count_listnode(head->;next);}return count;}}/*顺序打印*/void fdprint_listnode(List *head) {if(NULL != head){printf("%d\t",head->;val);if(head->;next != NULL){fdprint_listnode(head->;next);}}}/*反向打印*/void bkprint_listnode(List *head) {if(head != NULL){if(head->;next != NULL){bkprint_listnode(head->;next);}printf("%d\t",head->;val);}}/*删除一个节点的数据为d的节点*/List *delete_node(List * head, int d) {List *temp = head;if(head != NULL){if(head->;val == d){temp = head;head = head->;next;free(temp);temp = NULL;}else{temp = head->;next;if(temp != NULL){temp = delete_node(temp,d); head->;next = temp;}}}return head;}/*删除所有val = d的节点*/List* delete_allnode(List *head, int d) {List *temp = head, *cur = head;if(head != NULL){/*如果第一个就是需要删除的对象*/if(cur->;val == d){temp = cur;cur = cur->;next;free(temp);temp = NULL;temp = delete_allnode(cur, d); head = temp;}else /*不是删除的对象*/{cur = head->;next;temp = delete_allnode(cur, d);/*将得到的链表连接到检测的区域*/ head->;next = temp;}}return head;}/*最大值*/int max_list(List *head){int max = 0;int temp;if(NULL == head){printf("Error: NULL pointer...");}if(NULL != head && head->;next == NULL){return head->;val;}else{temp = max_list(head->;next);max = (head->;val >; temp ? head->;val : temp); return max;}}/*最小值*/int min_list(List *head){int min = 0;int temp;if(NULL == head){printf("Error: NULL pointer...");}if(NULL != head && head->;next == NULL){return head->;val;}else{temp = min_list(head->;next);min = (head->;val ;val : temp); return min;}}/*创建链表*/List* create_list(int val){List *head = (List*)malloc(sizeof(List)/sizeof(char)); if(NULL == head){return NULL;}head->;val = val;head->;next = NULL;return head;}/*插入节点*/List* insert_listnode(List *head, int val) {List *temp;if(NULL == head){return NULL;}temp = (List*)malloc(sizeof(List)/sizeof(char));temp->;val = val;temp->;next = head;head = temp;return head;}/*删除链表*/void delete_list(List *head) {List *temp = NULL;if(head != NULL){temp = head;head = head->;next;free(temp);temp = NULL;delete_list(head);}}int main(){int n = 0;int i = 0;List * head = create_list(10);for(i = 0; i < 10; ++ i){n = 1 + (int)(10.0*rand()/(RAND_MAX + 1.0)); head = insert_listnode(head, n);}fdprint_listnode(head);printf("\n");bkprint_listnode(head);printf("\n%d\n", count_listnode(head));printf("\n");#if 10head = delete_node(head, 10); fdprint_listnode(head);printf("\n");bkprint_listnode(head);printf("\n");#endif#if 10head = delete_allnode(head, 10);fdprint_listnode(head);printf("\n");bkprint_listnode(head);#endifprintf("max = %d\n",max_list(head)); printf("max = %d\n",min_list(head));delete_list(head);head = NULL;if(head == NULL){printf("ERROR:null pointer!...\n"); }return 0;}递归中需要注意的思想我任务就是为了解决当前的问题，我完成最简单的一部操作，其他的由别人去完成，比如汉诺塔中的第一个和尚让第二个和尚把前63个金盘放在B处，而他自己只需要完成从A到C的搬运，实质上他自己完成的只有一部最简答的，但是搬运这种动作有存在非常大的相似性。
链表的基本操作
链表的基本操作
链表是一种通用的数据结构，它利用指针对数据元素的每一个节点进行存储，当需要访问任何指定的节点时，受益于指针技术，可以较快的访问指定节点。
在一般的链表中，可以进行如下几种基本操作：
1.插入：链表可以在既有链表中的任何一个位置插入数据元素，通过改变相应指针指向，实现插入操作。
2.删除：链表也可以通过调整相应指针指向，实现删除操作。
3.搜索：在链表中搜索某个元素可以采用顺序搜索的方式，从链表的首元节点开始，逐个比较，直到找到所要查找节点。
4.遍历：链表可以从链表的首元节点开始，按照指针指向，依次访问每一个节点，从而实现对链表的元素的遍历。
5.修改：修改链表可以通过先将要修改的节点找出来，然后调整相应的数据值来实现。
链表的基本操作是一个非常常用的数据结构，可以有效的提高编程效率，更加方便的实现某些算法，广泛应用于很多的计算机程序。
所以在学习更多的数据结构的时候，了解链表的基本操作，也是一个不可忽视的组成部分。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：本实验的目的是通过实现单链表数据结构，加深对数据结构的理解，并掌握单链表的基本操作和算法。
实验内容：1、单链表的定义单链表由若干个节点组成，每个节点包含数据域和指针域，数据域存储具体数据，指针域指向下一个节点。
单链表的头指针指向链表的第一个节点。
2、单链表的基本操作2.1 初始化链表初始化链表时，将头指针置空，表示链表为空。
2.2 插入节点插入节点可以分为头插法和尾插法。
- 头插法：将新节点插入链表头部，新节点的指针域指向原头节点，头指针指向新节点。
- 尾插法：将新节点插入链表尾部，新节点的指针域置空，原尾节点的指针域指向新节点。
2.3 删除节点删除节点可以分为按位置删除和按值删除两种方式。
- 按位置删除：给定要删除节点的位置，修改前一节点的指针域即可。
- 按值删除：给定要删除节点的值，遍历链表找到对应节点，修改前一节点的指针域即可。
2.4 遍历链表遍历链表即按顺序访问链表的每个节点，并输出节点的数据。
2.5 查找节点查找节点可以分为按位置查找和按值查找两种方式。
- 按位置查找：给定节点的位置，通过遍历链表找到对应节点。
- 按值查找：给定节点的值，通过遍历链表找到第一个匹配的节点。
实验步骤：1、根据实验目的，定义单链表的结构体和基本操作函数。
2、实现初始化链表的函数，将头指针置空。
3、实现头插法或尾插法插入节点的函数。
4、实现按位置删除节点的函数。
5、实现按值删除节点的函数。
6、实现遍历链表的函数，输出节点的数据。
7、实现按位置查找节点的函数。
8、实现按值查找节点的函数。
9、设计实验样例，测试单链表的各种操作。
实验结果与分析：通过测试实验样例，我们可以验证单链表的各种操作是否正确。
如果出现异常情况，可通过调试找出问题所在，并进行修改。
单链表的操作时间复杂度与操作的位置有关，对于查找操作，时间复杂度为O(n)；对于插入和删除操作，时间复杂度也为O(n)。
附件：1、单链表的定义和基本操作的源代码文件。
单链表的实现及其基本操作
单链表的实现及其基本操作结点的引⼊链表是⼀种链式存储结构，链式存储结构的特点是⽤⼀组任意的存储单元存储数据元素。
为了能正确表⽰数据元素之间的线性关系，需引⼊结点概念。
⼀个结点表⽰链表中的⼀个数据元素，节点中除了储存数据元素的信息，还必须存放指向下⼀个节点的的指针（单、双链表的最后⼀个节点除外，它们存储的是⼀个空指针NULL）结点的结构如下图所⽰：代码如下：1 typedef struct node{2int data;3struct node* pNext;4 }Node, *PNode;View Code注：这⾥假设结点中储存的是整型 (int) 的数据单链表由多个结点依次连接⽽成，我们不难想象出它结构：我们注意到：在第⼀个结点的前⾯多了⼀个头结点，这是为了处理空表的⽅便⽽引⼊的，它的指针指向链表的第⼀个结点，⽽它的data域不存放任何信息。
单链表的基本操作1.创建链表1 PNode createList()2 {3int len, value;45 PNode pHead = (PNode)(malloc(sizeof(Node)));6 PNode pTail = pHead;7 pTail->pNext = NULL;89 printf("请输⼊你要的节点个数：");10 scanf("%d", &len);11for(int i=1;i<=len;i++){12 printf("请输⼊第%d个节点的值：", i);13 scanf("%d", &value);1415 PNode pNew = (PNode)malloc(sizeof(Node));16 pNew->data = value;17 pTail->pNext = pNew;18 pTail = pNew;19 pTail->pNext = NULL;20 }2122return pHead;23 }View Code2.遍历链表void traverse(PNode pHead){printf("遍历结果为:\n");PNode pTra = pHead;while(pTra->pNext != NULL){printf("%d ", pTra->pNext->data);pTra = pTra->pNext;}printf("\n");}View Code3.判断链表是否为空1bool isEmpty(PNode pHead)2 {3if(pHead->pNext==NULL)4return true;5else6return false;7 }View Code4.链表长度1int length(PNode pHead)2 {3int len = 0;4while(pHead->pNext!=NULL){5 pHead = pHead->pNext;6 len++;7 }8return len;910 }View Code5.插⼊结点1bool insert(PNode pHead, int pos, int val)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pInsert = pHead;7for(int i=1;i<pos;i++){8 pInsert = pInsert->pNext;9 }1011 PNode pNew = (PNode)malloc(sizeof(Node));12 pNew->data = val;13 pNew->pNext = pInsert->pNext;14 pInsert->pNext = pNew;1516return true;17 }1819 }View Code6.删除结点1bool del(PNode pHead, int pos)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pDel = pHead;7for(int i=1;i<pos;i++){8 pDel = pDel->pNext;9 }1011if(pos==length(pHead)){12free(pDel->pNext);13 pDel->pNext = NULL;14 }else{15 PNode pNext = pDel->pNext->pNext;16free(pDel->pNext);17 pDel->pNext = pNext;18 }1920return true;2122 }232425 }View Code7.查找节点（1）按元素值查找1 PNode locate(PNode pHead, int value)2 {3 PNode p = pHead->pNext;4while(p&&p->data!=value){ //NULL 是 05 p = p->pNext;6 }7return p;8 }View Code（2）按序号查找1 PNode get(PNode pHead, int k)2 {3 PNode p = pHead;4for(int i=1;i<=k;i++){5 p = p->pNext;6 }7return p;89 }View Code完整代码1 #include<stdio.h>2 #include<stdlib.h>3 typedef struct node{4int data;5struct node* pNext;6 }Node, *PNode;78 PNode createList();9void traverse(PNode pHead);10bool isEmpty(PNode pHead);11int length(PNode pHead);12bool insert(PNode pHead, int pos, int val);13bool del(PNode pHead, int pos);14 PNode get(PNode pHead, int k); //按序号查找15 PNode locate(PNode pHead, int value);//按值查找 1617int main(void)18 {19//test2021return0;22 }2324 PNode createList()25 {26int len, value;2728 PNode pHead = (PNode)(malloc(sizeof(Node)));29 PNode pTail = pHead;30 pTail->pNext = NULL;3132 printf("请输⼊你要的节点个数：");33 scanf("%d", &len);34for(int i=1;i<=len;i++){35 printf("请输⼊第%d个节点的值：", i);36 scanf("%d", &value);3738 PNode pNew = (PNode)malloc(sizeof(Node));39 pNew->data = value;40 pTail->pNext = pNew;41 pTail = pNew;42 pTail->pNext = NULL;43 }4445return pHead;46 }474849void traverse(PNode pHead)50 {51 printf("遍历结果为:\n");52 PNode pTra = pHead;53while(pTra->pNext != NULL)54 {55 printf("%d ", pTra->pNext->data);56 pTra = pTra->pNext;57 }58 printf("\n");59 }6061bool isEmpty(PNode pHead)62 {63if(pHead->pNext==NULL)64return true;65else66return false;67 }6869int length(PNode pHead)70 {71int len = 0;72while(pHead->pNext!=NULL){73 pHead = pHead->pNext;74 len++;75 }76return len;7778 }7980bool insert(PNode pHead, int pos, int val)81 {82if(pos<1 || pos>length(pHead)){83return false;84 }else{85 PNode pInsert = pHead;86for(int i=1;i<pos;i++){87 pInsert = pInsert->pNext;88 }8990 PNode pNew = (PNode)malloc(sizeof(Node));91 pNew->data = val;92 pNew->pNext = pInsert->pNext;93 pInsert->pNext = pNew;9495return true;96 }9798 }99100bool del(PNode pHead, int pos)101 {102if(pos<1 || pos>length(pHead)){103return false;104 }else{105 PNode pDel = pHead;106for(int i=1;i<pos;i++){107 pDel = pDel->pNext;108 }109110if(pos==length(pHead)){111free(pDel->pNext);112 pDel->pNext = NULL;113 }else{114 PNode pNext = pDel->pNext->pNext;115free(pDel->pNext);116 pDel->pNext = pNext;117 }118119return true;120121 }122123124 }125126 PNode get(PNode pHead, int k)127 {128 PNode p = pHead;129for(int i=1;i<=k;i++){130 p = p->pNext;131 }132return p;133134 }135 PNode locate(PNode pHead, int value)136 {137 PNode p = pHead->pNext;138while(p&&p->data!=value){ //NULL 是 0 139 p = p->pNext;140 }141return p;142 }View Code。
数据结构中链表及常见操作
链表1 定义链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。
由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。
但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
在计算机科学中，链表作为一种基础的数据结构可以用来生成其它类型的数据结构。
链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向明上一个或下一个节点的位置的链接（"links"）。
链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的访问往往要在不同的排列顺序中转换。
而链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）。
链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。
链表有很多种不同的类型：单向链表，双向链表以及循环链表。
2 结构2.1 单向链表链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。
这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。
一个单向链表的节点被分成两个部分。
第一个部分保存或者显示关于节点的信息，第二个部分存储下一个节点的地址。
单向链表只可向一个方向遍历。
链表最基本的结构是在每个节点保存数据和到下一个节点的地址，在最后一个节点保存一个特殊的结束标记，另外在一个固定的位置保存指向第一个节点的指针，有的时候也会同时储存指向最后一个节点的指针。
一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
case 4://求长度部分
int length;
length=ListLen(La);
printf("链表的长度为：%d\n",length);
break;
case 5://显示部分
ShowList(La);
break; case 0来自 printf("\n谢谢使用！\n"); return 0;
{
p=(LinkList)malloc(sizeof(LNode));
scanf("%d",&p->date);
p->next=L->next;
L->next=p;
}
}
void Creatlist2(LinkList &L,int n) //尾插法
{
L=(LinkList)malloc(sizeof(LNode));
struct LNode *next;
}LNode,*LinkList;
void Creatlist1(LinkList &L,int n) //头插法
{
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
LinkList p;
for(int i=n;i>0;--i)
return error;
}
ShowList(La);
break;
case 2: //插入部分
int e;
printf("请输入要插入元素的位置：");
scanf("%d",&n);
printf("请输入要插入的元素值：");
}
int main()
{
menu:
printf("\n\n*********请选择要对线性表进行的操作：*********\n1 建立，2 插入，3 删除，4 长度，5 显示，0 退出\n请选择操作序号：");
int flag;
scanf("%d",&flag);
switch(flag)
}
void ShowList(LinkList L) //输出显示
{
LinkList p;
p=L->next;
printf("元素为：");
while(p!=NULL)
{
printf("%-3d",p->date);
p=p->next;
}
printf("\n");
L->next=NULL;
LinkList p,q;
q=L;
for(int i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode));
scanf("%d",&p->date);
p->next=NULL;
q->next=p;
scanf("%d",&e);
Initlist(La,n,e);
ShowList(La);
break;
case 3: //删除部分
printf("请输入要删除元素的位置：");
scanf("%d",&n);
DelList(La,n);
ShowList(La);
q=q->next;
p->next=q->next;
q->next=p;
}
void DelList(LinkList &L,int n) //删除
{
LinkList p,q;
q=L;
for(int i=1;i<n;i++)
q=q->next;
p=q->next;
q=p;
}
}
void Initlist(LinkList &L,int n,int e) //插入
{
LinkList p,q;
q=L;
p=(LinkList)malloc(sizeof(LNode));
p->date=e;
for(int i=1;i<n;i++)
q->next=p->next;
free(p);
}
int ListLen(LinkList L) //长度
{
int len=0;
LinkList p;
p=L;
while(p->next!=NULL)
{
p=p->next;
len++;
}
return len;
if(flag2==1)
{
printf("请依次输入各个元素：\n");
Creatlist1(La,n);
}
else if(flag2==2)
{
printf("请依次输入各个元素：\n");
Creatlist2(La,n);
}
else
{
printf("输入的选择不存在！");
{
case 1://录入部分
int flag2;
int n;
LinkList La;
printf("请输入要输入的元素个数：\n");
scanf("%d",&n);
printf("请选择输入方式（1.逆序 2.正序）：\n");
scanf("%d",&flag2);
#include<stdio.h>
#include <stdlib.h>
#define ElemType int;
#define true 1
#define false 0
#define ok 1
#define error 0
typedef struct LNode{
int date;
}
goto menu;
}