单链表的插入和删除实验报告
单链表的基本操作实验报告

单链表的基本操作实验报告单链表的基本操作实验报告引言:单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中,我们将学习和实践单链表的基本操作,包括创建链表、插入节点、删除节点以及遍历链表等。
一、实验目的本次实验的主要目的是掌握单链表的基本操作,包括链表的创建、插入节点、删除节点和遍历链表。
通过实践操作,加深对单链表的理解,并掌握如何应用单链表解决实际问题。
二、实验过程1. 创建链表首先,我们需要创建一个空链表。
链表可以通过一个头节点来表示,头节点不存储数据,只用于标识链表的起始位置。
我们可以定义一个指针变量head,将其指向头节点。
2. 插入节点在链表中插入节点是常见的操作。
我们可以选择在链表的头部、尾部或者指定位置插入节点。
插入节点的过程可以分为以下几个步骤:a. 创建一个新节点,并为其赋值;b. 找到要插入位置的前一个节点;c. 将新节点的指针指向前一个节点的下一个节点;d. 将前一个节点的指针指向新节点。
3. 删除节点删除节点是另一个常见的操作。
我们可以选择删除链表的头节点、尾节点或者指定位置的节点。
删除节点的过程可以分为以下几个步骤:a. 找到要删除节点的前一个节点;b. 将前一个节点的指针指向要删除节点的下一个节点;c. 释放要删除节点的内存空间。
4. 遍历链表遍历链表是为了查看链表中的元素。
我们可以从头节点开始,依次访问每个节点,并输出节点的值。
三、实验结果在本次实验中,我们成功完成了单链表的基本操作。
通过创建链表、插入节点、删除节点和遍历链表等操作,我们可以方便地对链表进行增删改查操作。
四、实验总结通过本次实验,我们对单链表的基本操作有了更深入的了解。
单链表是一种非常重要的数据结构,广泛应用于各个领域。
掌握了单链表的基本操作,我们可以更好地解决实际问题,并且为以后学习更复杂的数据结构打下坚实的基础。
在实验过程中,我们还发现了一些问题和不足之处。
数据结构单链表插入、删除和修改实验报告

计算机学院实验报告课程名称:数据结构实验名称:单链表学生姓名:***学生学号:***********实验日期:2012一、实验目的1.理解数据结构中带头结点单链表的定义和逻辑图表示方法。
2.掌握单链表中结点结构的C++描述。
3.熟练掌握单链表的插入、删除和查询算法的设计与C++实现。
二、实验内容1.编制一个演示单链表插入、删除、查找等操作的程序。
三、实验步骤1.需求分析本演示程序用C++6.0编写,完成单链表的生成,任意位置的插入、删除,以及确定某一元素在单链表中的位置。
①输入的形式和输入值的范围:插入元素时需要输入插入的位置和元素的值;删除元素时输入删除元素的位置;查找操作时需要输入元素的值。
在所有输入中,元素的值都是整数。
②输出的形式:在所有三种操作中都显示操作是否正确以及操作后单链表的内容。
其中删除操作后显示删除的元素的值,查找操作后显示要查找元素的位置。
③程序所能达到的功能:完成单链表的生成(通过插入操作)、插入、删除、查找操作。
④测试数据:A.插入操作中依次输入11,12,13,14,15,16,生成一个单链表B.查找操作中依次输入12,15,22返回这3个元素在单链表中的位置C.删除操作中依次输入2,5,删除位于2和5的元素2.概要设计1)为了实现上述程序功能,需要定义单链表的抽象数据类型:(1)insert初始化状态:单链表可以不为空集;操作结果:插入一个空的单链表L。
(2)decelt操作结果:删除已有的单链表的某些结点。
(3)display操作结果:将上述输入的元素进行排列显示。
(4)modify操作结果:将上述输入的某些元素进行修改。
(5)save操作结果:对上述所有元素进行保存。
(6)load操作结果:对上述元素进行重新装载。
3.使用说明程序执行后显示======================1.单链表的创建2.单链表的显示3.单链表的长度4.取第i个位置的元素5.修改第i个位置的元素6.插入元素到单链表里7.删除单链表里的元素8.合并两个单链表9.退出系统=======================5.源代码:#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n){ LinkList p;L=new LNode;L->next=NULL;LinkList q=L;for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e){ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error;e=p->data;return ok;}Status LinkInsert(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=new LNode;s->data=e;s->next=p->next;p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e){ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){p=p->next;++j; }if(!(p->next)||j>i-1) return error;q=p->next;p->next=q->next;e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) {LinkList pa,pc,pb;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;delete(Lb);}void show(LinkList L){ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i){ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L){ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing(){ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main(){ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误,请重新输入"<<endl;break;}}}6.测试结果四、实验总结(结果分析和体会)单链表的最后一个元素的next为null ,所以,一旦遍历到末尾结点就不能再重新开始;而循环链表的最后一个元素的next为第一个元素地址,可返回头结点进行重新遍历和查找。
单链表的实验报告

单链表的实验报告单链表的实验报告引言:单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中,我们将学习如何使用单链表来实现一些基本的操作,并通过实验验证其功能和效率。
一、实验目的本次实验的主要目的是掌握单链表的基本概念和操作方法,包括插入、删除、查找等操作,并通过实际操作来验证其正确性和效率。
二、实验过程1. 单链表的定义和初始化首先,我们需要定义一个单链表的结构,并初始化一个空链表。
链表的结构可以使用C语言中的结构体来表示,其中包含一个数据域和一个指向下一个节点的指针。
2. 插入操作在已有链表中插入一个新的节点,可以分为两种情况:在链表头部插入和在链表中间插入。
我们可以通过修改指针的指向来实现插入操作。
3. 删除操作删除链表中的一个节点,同样可以分为两种情况:删除头节点和删除中间节点。
删除操作需要注意指针的重新连接,以防止链表断裂。
4. 查找操作在链表中查找指定的元素,可以通过遍历链表的方式来实现。
从链表头开始,依次比较节点的数据域,直到找到目标元素或者遍历到链表尾部。
5. 其他操作在实际应用中,还可以对链表进行排序、逆序、合并等操作,这些操作都可以通过适当的算法来实现。
三、实验结果通过实际操作,我们验证了单链表的各种操作方法的正确性和效率。
在插入、删除和查找操作中,链表的时间复杂度为O(n),其中n为链表的长度。
而在其他操作中,时间复杂度则根据具体算法的实现方式而定。
四、实验总结通过本次实验,我们深入了解了单链表的结构和操作方法,并通过实际操作来验证了其功能和效率。
单链表作为一种常用的数据结构,在实际应用中具有广泛的用途,例如链表可以用来实现栈、队列等其他数据结构,也可以用于解决一些实际问题,如链表的反转、环的检测等。
总之,掌握单链表的基本概念和操作方法对于学习和理解数据结构具有重要意义。
通过实验的方式,我们不仅能够加深对单链表的理解,还能够提高编程能力和解决实际问题的能力。
数据结构单链表实验报告

数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。
实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。
利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第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指向的节点即为要删除的节点。
数据结构C语言单链表上实现插入和删除的算法实验报告

一、实验目的1.掌握单链表的基本操作:插入、删除、查找以及表的合并等运算。
2.掌握运用C语言上机调试单链表的基本方法。
二、实验任务1.试编写在单链表上实现插入和删除的算法。
三、程序流程图四、测试过程及结果五、总结1.程序特点:最小化、模块化、for循环。
2.单链表特点:动态分配内存、必须从已知指针逐一查找数据、通过改变数据间的链接改变顺序。
附录程序清单#include <stdio.h>#include <stdlib.h>struct NODE{int data;NODE *next;};NODE *creatlink(){NODE *head,*p,*s;int i,n;head=(NODE *)malloc(sizeof(NODE));p=head;scanf("%d",&n);for(i=0;i<n;i++){s=(NODE *)malloc(sizeof(NODE));scanf("%d",&s->data);p->next=s;p=s;}p->next=0;return head;}void print(NODE *p){for(p=p->next;p!=0;p=p->next)printf("%d ",p->data);printf("\n");}void insert(NODE *p,int i,int x){NODE *s;int j;for(j=1;j<i;j++)p=p->next;s=(NODE *)malloc(sizeof(NODE));s->data=x;s->next=p->next;p->next=s;}void Delete(NODE *p,int i){NODE *s;int j;for(j=1;j<i;j++)p=p->next;s=p->next;p->next=s->next;free(s);}void main(){int i,x;NODE A=*creatlink();scanf("%d%d",&i,&x);insert(&A,i,x);print(&A);scanf("%d",&i);Delete(&A,i);print(&A);}。
单链表的实验报告总结

单链表的实验报告总结单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含了数据和指向下一个节点的指针。
在实验中,我们对单链表进行了操作和实现,通过此次实验,我深刻理解了单链表的特点和应用。
以下是我对此次实验的总结和体会。
在实验中我们实现了单链表的创建和初始化。
通过创建一个头节点,并将头节点的指针指向空,我们成功地初始化了一个空的单链表。
这为后续的操作打下了基础。
接着,我们实现了单链表的插入操作。
通过指定要插入的位置和值,我们可以在单链表的任意位置插入一个新的节点。
这个操作非常灵活,让我感受到了单链表的动态性和可变性。
通过插入操作,我们可以在单链表中任意位置插入新的元素,从而灵活地调整单链表的结构和内容。
在实验中,我们还实现了单链表的删除操作。
通过指定要删除的节点位置,我们可以将该节点从单链表中删除。
这个操作也非常重要,可以帮助我们对单链表中的数据进行动态管理。
通过删除操作,我们可以方便地删除单链表中的某个元素,从而保持单链表的整洁和有序。
除了插入和删除操作,我们还实现了单链表的查找操作。
通过指定要查找的值,我们可以在单链表中查找到对应的节点。
这个操作非常实用,可以帮助我们快速定位和访问单链表中的数据。
通过查找操作,我们可以方便地获取单链表中特定元素的值,从而满足我们对数据的需求。
在实验中,我们还实现了单链表的修改操作。
通过指定要修改的节点位置和新的值,我们可以将单链表中某个节点的值进行修改。
这个操作也非常有用,可以帮助我们对单链表中的数据进行更新和改进。
通过修改操作,我们可以方便地对单链表中的某个元素进行数值的调整,从而满足我们对数据的要求。
通过本次实验,我对单链表的原理和操作有了更深入的理解。
单链表是一种非常灵活和实用的数据结构,可以应用于各种场景和问题。
它的特点是插入和删除操作的效率很高,但查找和修改操作的效率较低。
因此,在实际应用中,我们需要根据具体的需求和场景选择合适的数据结构。
数据结构单链表实验报告

数据结构单链表实验报告数据结构单链表实验报告一、实验目的本次实验的主要目的是通过实现单链表数据结构,加深对链表的理解,并通过实际操作掌握链表的基本操作。
二、实验环境1.操作系统:Windows 102.开发环境:C/C++语言3.开发工具:Visual Studio 2019三、实验内容本次实验的内容包括以下几个方面:1.单链表的定义与初始化1.1 单链表的结构定义1.2 创建一个空链表1.3 判断链表是否为空2.单链表的基本操作2.1 在链表头部插入节点2.3 在指定位置插入节点2.4 删除链表的指定节点2.5 查找链表中指定位置的节点2.6 修改链表中指定位置的节点2.7 输出链表中的所有节点3.单链表的应用示例3.1 操作链表实现栈3.2 操作链表实现队列3.3 链表逆置四、实验步骤与结果1.实验步骤1.1 定义一个节点结构体,包含数据域和指针域 1.2 创建一个空链表1.3 插入节点到链表的指定位置1.4 删除链表中的指定节点1.5 修改链表中的指定节点1.7 实现链表的应用示例2.实验结果经过以上步骤的操作,我们成功实现了单链表的各种基本操作,并实现了链表作为栈和队列的应用示例。
五、实验总结通过本次实验,我们深入理解了单链表的原理和基本操作,掌握了链表的插入、删除、查找等操作方法。
同时,我们还学会了如何应用链表来实现栈和队列等数据结构。
通过实际操作,巩固了对数据结构的理解和应用能力。
附件:无法律名词及注释:1.数据结构:是计算机存储、组织数据的方式,是指一组数据的表达方式,以及定义在该组数据上的一组操作。
2.链表:链表是一种常见的数据结构,用于存储有序的元素集合。
每个节点包含一个元素和一个指向下一个节点的指针。
数据结构单链表实验报告

数据结构单链表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中单链表的基本概念、操作原理和实现方法。
通过实际编程实现单链表的创建、插入、删除、查找等操作,提高对数据结构的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为 C 语言,开发环境为 Visual Studio 2019。
三、实验原理单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据域和指针域。
数据域用于存储节点的数据信息,指针域用于指向下一个节点的地址。
通过这种链式结构,可以方便地进行节点的插入、删除和遍历等操作。
四、实验内容与步骤1、单链表节点的定义```ctypedef struct Node {int data;struct Node next;} Node;```2、单链表的创建```cNode createList(){Node head = NULL;Node newNode;int data;printf("请输入节点数据(输入-1 结束):\n");scanf("%d",&data);while (data!=-1) {newNode =(Node)malloc(sizeof(Node));newNode>data = data;newNode>next = NULL;if (head == NULL) {head = newNode;} else {Node temp = head;while (temp>next!= NULL) {temp = temp>next;}temp>next = newNode;}scanf("%d",&data);}return head;}```3、单链表的插入操作```cvoid insertNode(Node head, int position, int data) {Node newNode =(Node)malloc(sizeof(Node));newNode>data = data;newNode>next = NULL;if (position == 1) {newNode>next = head;head = newNode;} else {Node temp = head;int count = 1;while (temp!= NULL && count < position 1) {temp = temp>next;count++;}if (temp!= NULL) {newNode>next = temp>next;temp>next = newNode;} else {printf("插入位置无效!\n");}}}```4、单链表的删除操作```cvoid deleteNode(Node head, int position) {if (head == NULL) {printf("链表为空,无法删除!\n");return;}Node temp = head;if (position == 1) {head = head>next;free(temp);} else {Node prev = NULL;int count = 1;while (temp!= NULL && count < position) {prev = temp;temp = temp>next;count++;}if (temp!= NULL) {prev>next = temp>next;free(temp);} else {printf("删除位置无效!\n");}}}```5、单链表的查找操作```cNode searchNode(Node head, int data) {Node temp = head;while (temp!= NULL) {if (temp>data == data) {return temp;}temp = temp>next;}return NULL;}```6、单链表的遍历打印```cvoid printList(Node head) {Node temp = head;while (temp!= NULL) {printf("%d ", temp>data);temp = temp>next;}printf("\n");}```五、实验结果与分析1、创建单链表输入一系列整数,成功创建了单链表。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
PrintList(L);
}
printf("the position after:");
scanf("%s",ch1);
InsertList(L,ch1);
PrintList(L);
FreeAll(L); //删除所有结点,释放内存
===================linkList.h=====================
#ifndef _LINK_LIST_H_
#define _LINK_LIST_H_
#include "common.h"
typedef char ElemType[10];
typedef struct LNode{
s->next=r->next;
r->next=s;
}
//===========在屏幕上输出所有节点元素==========
void PrintList(LinkList L)
{
LNode *p=L->next;
while(p)
{
printf("%s, ",p->data);
p=p->next;
}
printf("\n");
}
===================linkList.cpp=====================
#include "linkList.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
//==========用尾插入法建立带头结点的单链表============
}
//==========删除所有结点,释放空间===========
void FreeAll(LinkList L)
{
LNode *r,*p=L;
while(p->next)
{r=p->next;
free(p);
p=r;
}
free(p);
}
===================commom.h=====================
void DeleteList(LinkList L,ElemType key)
{
LNode *p,*r,*q=L;
p=LocateNode(L,key); //按key值查找结点的
if(p==NULL )//若没有找到结点,退出
{
printf("position error");
exit(0);
}
s->next=r->next;
r->next=s;
}
printf("Please input LNode data:\n");
scanf("%s",key);
}
return L;
}
//==========按值查找结点,找到则返回该结点的位置,否则返回NULL==========
LinkList LocateNode(LinkList L,ElemType key)
#ifndef _COMM_H_
#define _COMM_H_
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#endif
ElemType data; //数据域
struct LNode *next; //指针域
}LNode, *LinkList;
LinkList CreateList();
LinkList LocateNode(LinkList L,ElemType key);
void DeleteList(LinkList L,ElemType key);
{
ElemType input;
LNode *s,*r;
printf("input the Insert_data:");
scanf("%s",input);
r=LocateNode(L,key);
s=(LinkList)malloc(sizeof(LNode));
strcpy(s->data,input);
printf("Please input LNode data:\n");
scanf("%s",key);
while(strcmp(key,"#")!=0)
{
t=LocateNode(L,key);
if(t==NULL)
{
s=(LinkList)malloc(sizeof(LNode));
strcpy(s->data,key);
输入数据(bat,cat,eat,fat,hat,jat,lat,mat,#)
程序运行结果:
如删除hat程序运行结果为:
while(q->next!=p) //p为要删除的结点,q为p的前结点
q=q->next;
r=q->next;
q->next=r->next;
free(r); //释放结点
}
//==========插入元素到带头结点的单链表中的指定结点前=======
void InsertList(LinkList L,ElemType key)
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "linkList.h"
void main()
{
char ch[10],num[10],ch1[10];
LinkList L;
L=CreateList(); //用尾插入法建立单链表,返回头指针
其中链表的建立为头插入法。
链表建立示意图:
(a)、删除hat:
(b)、插入charu:
2、修改程序:
1)增加插入结点的功能。
如在jat后插入charu,程序运行结果为:
2)将建立链表的方法改为头插入法。
程序源代码:
===================main.cpp=====================
{
LNode *p;
p=L->next; //从开始结点比较
while(p&&strcmp(p->data,key)!=0) //直到p为NULL或p-> data为key止
p=p->next; //扫描下一个结点
return p; //若p=NULL则查找失败,否则p指向找到的值为key的结点
}
//==========删除带头结点的单链表中的指定结点=======
void InsertList(LinkList L,ElemType key);
void PrintList(LinkList L);
void FreeAll(LinkList L);
#endif
实验结果:
调试程序,并设计输入数据(如:bat,cat,eat,fat,hat,jat,lat,mat,#),测试程序的如下功能:不允许重复字符串的插入;根据输入的字符串,找到相应的结点并删除。
单链表的插入和删除实验报告
一、目的:
了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。
二、要求:
建立一个数据域定义为字符串的单链表,在链表中不允许有重复的字符串;根据输入的字符串,先找到相应的结点,后删除之。
三、实验内容:
1、分析、理解程序。
程序的主要功能是实现对数据域为字符串的单链表的建立、查找、删除、插入和浏览。
LinkList CreateList()
{
ElemType key;
LNode *r,*s,*t;
LinkList L=(LinkList)malloc(sizeof(LNode));//生成头结点
r=L;
r->next=NULL;
printf("Input # to end\n"); //输入“#”代表输入结束
PrintList(L); //遍历链表输出其值
printf(" Delete node (y/n):"); //输入"y"或"n"去选择是否删除结点
scanf("%s",num);
if(strcmp(num,"y")==0 || strcmp(num,"Y")==0)
{
printf("Please input Delete_data:");