单链表的插入和删除实验报告

合集下载

单链表的基本操作实验报告

单链表的基本操作实验报告单链表的基本操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

在本次实验中，我们将学习和实践单链表的基本操作，包括创建链表、插入节点、删除节点以及遍历链表等。

一、实验目的本次实验的主要目的是掌握单链表的基本操作，包括链表的创建、插入节点、删除节点和遍历链表。

通过实践操作，加深对单链表的理解，并掌握如何应用单链表解决实际问题。

二、实验过程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、通过实际编程，提高对数据结构和算法的理解和应用能力。

二、实验环境1、操作系统：Windows 102、编程语言：C 语言3、开发工具：Visual Studio 2019三、实验原理单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据域和指针域。

指针域用于指向下一个节点，从而形成链表的链式结构。

单链表的基本操作包括：1、创建链表：通过动态分配内存创建链表的头节点，并初始化链表为空。

2、插入节点：可以在链表的头部、尾部或指定位置插入新的节点。

3、删除节点：根据给定的条件删除链表中的节点。

4、查找节点：在链表中查找满足特定条件的节点。

四、实验内容（一）单链表的创建｀｀｀cinclude ＜stdioh>include ＜stdlibh>／／定义链表节点结构体typedef struct Node ｛int data;struct Node next;｝ Node;／／创建单链表Node createList(）｛Node head ＝（Node)malloc(sizeof(Node)）；if （head ＝＝ NULL) ｛printf(＂内存分配失败！＼n"）；return NULL;｝head>data ＝ 0;head>next ＝ NULL;return head;｝int main(）｛Node list ＝ createList(）；／／后续操作return 0;｝｀｀｀在创建单链表时，首先为头节点分配内存空间。

若内存分配失败，则提示错误信息并返回｀NULL`。

成功分配内存后，初始化头节点的数据域和指针域。

（二）单链表的插入操作插入操作分为三种情况：头部插入、尾部插入和指定位置插入。

1、头部插入｀｀｀cvoid insertAtHead(Node head, int data) ｛Node newNode ＝（Node)malloc(sizeof(Node)）；if （newNode ＝＝ NULL) ｛printf(＂内存分配失败！＼n"）；return;｝newNode>data ＝ data;newNode>next ＝ head>next;head>next ＝ newNode;｝｀｀｀头部插入时，创建新节点，将新节点的数据域赋值，并将其指针域指向原头节点的下一个节点，然后更新头节点的指针域指向新节点。

单链表操作实验报告

s->data=x;
for(q=head;(q!=NULL)&&(j<=i-1);j++)
q=q->next;
if(q!=NULL)
{
printf("\t插入成功！\n");
s->next=q->next;
q->next=s;
}
else printf("\t插入失败！\n");
return(head);
case 4:head=Linkdelete(head);Linkprint(head);break;
case 5:Linkprint(head);break;
case 6:exit(0);
}
}
}
五．测试结果
1.程序运行界面
{
p=p->next;
i++;
}
if(p->data==x)
{
printf("\t查找成功！\n");
printf("\t输出查找的数据所在位置为:%d\n",i);
}
else printf("\t查找结点不存在！\n");
}
linklist *Linkinsert(linklist *head)
{
printf("\t5.输出单链表\n");
printf("\t6.退出\n");
do{
printf("\t请输入选择的功能：");
scanf("%d",&k);
printf(" -------------------------------\n");

单链表的操作实验报告

单链表的操作实验报告《单链表的操作实验报告》在计算机科学领域，数据结构是非常重要的基础知识之一。

而单链表作为一种常见的数据结构，经常被用来存储和操作数据。

在本次实验中，我们将对单链表的操作进行实验，并撰写实验报告以总结和分享我们的实验结果。

实验目的：1. 了解单链表的基本概念和操作方法。

2. 掌握单链表的插入、删除、查找等操作。

3. 通过实际操作加深对单链表的理解和掌握。

实验环境：1. 编程语言：C/C++2. 开发环境：Visual Studio Code3. 实验工具：GCC编译器实验步骤：1. 定义单链表的结构体，并实现初始化、插入、删除、查找等操作的函数。

2. 编写测试用例，对单链表的各种操作进行测试。

3. 分析实验结果，总结操作的时间复杂度和空间复杂度。

4. 撰写实验报告，分享实验过程和结果。

实验结果：经过实验，我们成功实现了单链表的初始化、插入、删除、查找等操作，并对这些操作进行了充分的测试。

我们发现单链表的插入和删除操作的时间复杂度为O(1)，而查找操作的时间复杂度为O(n)，其中n为链表的长度。

这些结果与我们的预期相符合，说明我们对单链表的操作有了较好的掌握。

实验总结：通过本次实验，我们不仅加深了对单链表的理解，还提高了编程能力和数据结构的应用能力。

我们对单链表的操作有了更深入的了解，为以后在实际项目中应用单链表打下了良好的基础。

结语：单链表作为一种常见的数据结构，在实际应用中具有重要的作用。

通过本次实验，我们对单链表的操作有了更深入的了解，相信在以后的学习和工作中能够更好地应用和运用单链表。

希望本次实验报告能够对读者有所帮助，也欢迎大家对实验结果进行讨论和交流。

单链表地插入和删除实验报告材料

实用文档实验一、单链表的插入和删除一、目的了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。

二、要求：建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。

三、程序源代码#include"stdio.h"#include"string.h"#include"stdlib.h"#include"ctype.h"typedef struct node //定义结点{char data[10]; //结点的数据域为字符串struct node *next; //结点的指针域}ListNode;typedef ListNode * LinkList; // 自定义LinkList单链表类型LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表ListNode *LocateNode(); //函数，按值查找结点void DeleteList(); //函数，删除指定值的结点void printlist(); //函数，打印链表中的所有值void DeleteAll(); //函数，删除所有结点，释放内存//==========主函数==============void main(){char ch[10],num[10];LinkList head;head=CreatListR1(); //用尾插入法建立单链表，返回头指针 printlist(head); //遍历链表输出其值printf(" Delete node (y/n):");//输入“y”或“n”去选择是否删除结点scanf("%s",num);if(strcmp(num,"y")==0 || strcmp(num,"Y")==0){ printf("Please input Delete_data:");scanf("%s",ch); //输入要删除的字符串 DeleteList(head,ch);printlist(head);}DeleteAll(head); //删除所有结点，释放内存}//==========用尾插入法建立带头结点的单链表===========LinkList CreatListR1(void){char ch[10];LinkList head=(LinkList)malloc(sizeof(ListNode)); //生成头结点ListNode *s,*r,*pp;r=head;r->next=NULL;printf("Input # to end "); //输入“#”代表输入结束printf("Please input Node_data:");scanf("%s",ch); //输入各结点的字符串while(strcmp(ch,"#")!=0) {pp=LocateNode(head,ch); //按值查找结点，返回结点指针 if(pp==NULL) { //没有重复的字符串，插入到链表中s=(ListNode *)malloc(sizeof(ListNode));strcpy(s->data,ch);r->next=s;r=s;r->next=NULL;}printf("Input # to end ");printf("Please input Node_data:");scanf("%s",ch);}return head; //返回头指针}//==========按值查找结点，找到则返回该结点的位置，否则返回NULL==========ListNode *LocateNode(LinkList head, char *key){ListNode *p=head->next; //从开始结点比较while(p&&strcmp(p->data,key)!=0 ) //直到p为NULL或p-> data为key止p=p->next; //扫描下一个结点return p; //若p=NULL则查找失败，否则p指向找到的值key的结点}//==========删除带头结点的单链表中的指定结点=======void DeleteList(LinkList head,char *key){ListNode *p,*r,*q=head;p=LocateNode(head,key); //按key值查找结点的if(p==NULL ) { //若没有找到结点，退出printf("position error");exit(0);}while(q->next!=p) //p为要删除的结点，q为p的前结点q=q->next;r=q->next;q->next=r->next;free(r); //释放结点}//===========打印链表=======void printlist(LinkList head){ListNode *p=head->next; //从开始结点打印while(p){printf("%s, ",p->data);p=p->next;}printf("\n");}//==========删除所有结点，释放空间===========void DeleteAll(LinkList head){ListNode *p=head,*r;while(p->next){r=p->next;free(p);p=r;}free(p);}运行结果：加的添加结点的代码：int Insert(ListNode *head) // the insert function {ListNode *in,*p,*q;int wh;printf("input the insert node:");in=(ListNode *)malloc(sizeof(ListNode));in->next=NULL;p=(ListNode *)malloc(sizeof(ListNode));p->next=NULL;q=(ListNode *)malloc(sizeof(ListNode));q->next=NULL;if(!in)return 0;scanf("%s",in->data);printf("input the place where you want to insert you data:");scanf("%d",&wh);for(p=head;wh>0;p=p->next,wh--);q=p->next;p->next=in;in->next=q;return 1;}运行结果：最后提示为OK 添加成功。

实验二单链表的插入和删除

实验二单链表的插入和删除1.实验目的：了解单链表的基本概念、结构的定义及在单链表上的基本操作(插入、删除、查找以及线性表合并)，通过在VC 实现以上操作更好的了解书本上的内容并体会线性表的两种存储结构的区别。

2.实验预备知识：⑴ 复习C 语言中指针的用法，特别是结构体的指针的用法；⑵ 了解单链表的概念，单链表的定义方法；单链表是线性表的链式存储表示，是用一组任意的存储单元依次存储线性表的数据元素。

因此，为了表示每个数据元素a i 与其直接后继元素a i+1之间的逻辑关系，对数据元素ai 来说，，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置），而这部分就是用指针来完成的。

⑶ 掌握线性表在链式存储结构上实现基本操作：查找、插入、删除的算法；在实现这些算法的时候，要注意判断输入数据的合法性，除此之外还要要注意以下内容：在实现查找的时候，首先要判断该顺序表是否为空，其次要判断查找后的结果(查到时输出查到的数据，未查到时给出错误提示)。

在实现插入的时候，由于是链式存储，它可以随机产生和回收存储空间，所以它不要判断线性表是否为满，但仍需判断要插入的位置是否合法，原因同实验一，其次要注意插入的时候语句的顺序不可颠倒，否则出错。

例如：s 所指向结点要插入在p 所指向的结点之后，则：正确形式：s->next=p->nextp->next=s错误形式：p->next=ss->next=p->next(因为此时p->next 已经指向s 了)在实现删除的时候，首先要判断线性表是否为空，为空则不能删除；其次在删除后要回收空间。

例如：删除如上图所示s 所指向的结点p->next=p->next->nextfree s3.实验内容：⑴ 单链表的插入算法⑵ 单链表的删除算法⑶循环链表的插入和删除算法4.部分实验代码：⑴单链表的结构定义：#include <stdio.h>typedef int elemtype;typedef struct lnode{ elemtype data;struct lnode *next;}*linklist;⑵建立单链表的算法int n; /*n作为整个程序的全局变量*/linklist *creat(void){ linklist *head, *p1, *p2;n=0;p1=p2=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);head=null;while(p1->data!=0){ n=n+1;if(n==1) head=p1;else p2->next=p1;p2=p1;p1=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);}p2->next=null;return(head);}⑶单链表的插入算法int insert(linklist *head, int i,elemtype e) { linklist *p, *s;int j;p=head; j=0;while(p && j<i-1){ p=p->next;++j;}if(!p||j>i-1){ printf(“无法插入”)；return 0;}s=(linklist *)malloc(sizeof(lnode));s->data=e;s->next=p->next;p->next=s;return 1;}⑷单链表的删除算法int deltree(linklist *head,int i,elemtype e){ linklist *p, *q;int j;lp=head; j=0;while(p->next && j<i-1){ p=p->next;++j;}if(!(p->next)||j>i-1){ printf(“无法删除”);return 0;}q=p->next;p->next=q->next;e=q->data;free(q);return 1;}。

单链表的操作实验报告

单链表的操作实验报告单链表的操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。

在本次实验中，我们将学习如何使用C语言实现单链表的基本操作，包括插入、删除和查找等。

一、单链表的定义和初始化单链表由节点组成，每个节点包含数据和指向下一个节点的指针。

首先，我们需要定义一个节点的结构体，如下所示：```struct Node {int data; // 节点数据struct Node* next; // 指向下一个节点的指针};```在初始化单链表之前，我们需要创建一个头节点，它不存储任何数据，只用于指向第一个节点。

初始化单链表的代码如下：```struct Node* head = NULL; // 头节点初始化为空```二、单链表的插入操作插入操作是向单链表中添加新节点的过程。

我们可以在链表的头部、尾部或者指定位置插入新节点。

下面以在链表头部插入新节点为例进行说明。

首先，我们需要创建一个新节点，并为其分配内存空间：```struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));```然后，为新节点赋值并将其插入到链表头部：```newNode->data = 10; // 赋值新节点的数据newNode->next = head; // 将新节点的指针指向原头节点head = newNode; // 将头节点指向新节点```三、单链表的删除操作删除操作是从单链表中删除指定节点的过程。

我们可以根据节点的位置或者数据进行删除。

下面以删除链表中指定数据的节点为例进行说明。

首先，我们需要遍历链表找到要删除的节点，并记录其前一个节点的地址：```struct Node* current = head;struct Node* previous = NULL;int targetData = 10; // 要删除的节点数据while (current != NULL && current->data != targetData) {previous = current;current = current->next;}```然后，将前一个节点的指针指向要删除节点的下一个节点，并释放要删除节点的内存空间：```previous->next = current->next;free(current);```四、单链表的查找操作查找操作是在单链表中查找指定数据的节点。

单链表实验总结

单链表实验总结单链表是一种常见的数据结构，用于存储有序的数据元素。

在这个实验中，我通过实现单链表的基本操作，如插入、删除和查找等，加深了对单链表的理解。

在实验中，我首先创建了一个单链表的类，并实现了构造函数。

然后，我实现了向链表中插入节点的操作。

插入节点时，我需要将新的节点的指针指向当前节点的下一个节点，然后将前一个节点的指针指向新的节点，从而完成节点的插入。

在实现删除节点的操作时，我需要找到要删除的节点的前一个节点，然后将前一个节点的指针指向要删除节点的下一个节点，从而将要删除的节点排除在链表之外。

我还实现了通过索引查找节点的操作。

在这个操作中，我需要从链表的头节点开始迭代，直到找到要查找的索引位置的节点。

通过实践，我发现单链表的插入和删除操作的时间复杂度都是O(n)，其中n表示链表的长度。

在查找操作中，时间复杂度是O(n)。

总之，通过这个实验，我对单链表的原理和基本操作有了更深的理解。

我也学到了如何使用单链表来解决实际问题。

这个实验让我更加熟悉了链表的概念和操作，为我进一步深入学习数据结构和算法打下了基础。

除了实现基本的插入、删除和查找操作，我还尝试了一些其他的操作来进一步加深对单链表的理解。

首先，我实现了获取链表长度的操作。

通过遍历整个链表，我可以统计节点的数量来得到链表的长度。

这个操作的时间复杂度是O(n)。

接下来，我尝试实现了链表的反转操作。

通过调整节点的指针指向，我可以将链表的顺序颠倒过来。

这个操作的时间复杂度是O(n)。

另外，我实现了链表的判空和清空操作。

判空操作可以判断链表是否为空，即链表的头节点是否为空。

清空操作可以将链表中的所有节点都删除，使链表变为空链表。

最后，我尝试了一些高级操作，如链表的排序和链表的合并。

排序操作可以将链表中的节点按照一定的顺序重新排列，通常使用冒泡排序、选择排序或插入排序等算法实现。

合并操作可以将两个有序链表合并成一个更大的有序链表，通常使用归并排序的思想实现。

数据结构单链表实验报告

数据结构单链表实验报告数据结构单链表实验报告1. 引言数据结构是计算机科学中的重要基础，它研究数据的组织、存储和管理方式。

单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。

本实验旨在通过实践操作单链表，加深对数据结构的理解。

2. 实验目的本实验的主要目的是掌握单链表的基本操作，包括创建链表、插入节点、删除节点和遍历链表。

通过实践操作，加深对链表的理解，提高编程能力和解决问题的能力。

3. 实验环境和工具本实验使用C语言进行编程实现，可以选择任何C语言开发环境，如Dev-C++、Code::Blocks等。

在编程过程中，可以使用任何文本编辑器编写代码。

4. 实验步骤4.1 创建链表首先，需要定义一个节点结构体，包含数据和指向下一个节点的指针。

然后，通过动态内存分配来创建链表的第一个节点，并将其地址赋给头指针。

接下来，可以通过输入数据的方式，逐个创建链表的其他节点。

4.2 插入节点在链表中插入节点是一种常见的操作。

可以在链表的任意位置插入一个新节点，只需要修改相应节点的指针即可。

首先，需要找到插入位置的前一个节点，然后将新节点的指针指向原来的下一个节点，再将前一个节点的指针指向新节点。

4.3 删除节点删除链表中的节点也是一种常见的操作。

可以根据节点的值或位置来删除节点。

首先，需要找到要删除的节点的前一个节点，然后将前一个节点的指针指向要删除节点的下一个节点，最后释放要删除节点的内存空间。

4.4 遍历链表遍历链表是一种查看链表中所有节点的操作。

可以通过循环遍历链表中的每个节点，输出节点的值或进行其他操作。

需要注意的是，遍历链表时需要使用一个临时指针来指向当前节点，以便于移动到下一个节点。

5. 实验结果与分析通过实验，我们成功实现了单链表的创建、插入、删除和遍历操作。

在实际应用中，单链表可以用于实现各种数据结构和算法，如栈、队列和图等。

它具有灵活性和高效性的特点，可以方便地进行节点的插入和删除操作。

单链表的插入和删除

实验一单链表的插入和删除（4个机时）1.1 实验目的：已知线性表中元素为“TANKK︼YOU”，利用模块化编程思想，编程实现如下函数功能：1）建立一个带头结点的单链表，将线性表中元素依次放入(函数1)；输出该单链表中各元素(函数4)。

2）删除单链表中的第四个元素(函数2)；输出执行删除操作之后的单链表(函数4)；3）在单链表中的第二个元素前插入元素“H”(函数3)；输出执行插入操作之后的单链表(函数4)。

1.2 流程图”1.3 实验步骤及程序代码#include<stdio.h>#include<string.h>#include<malloc.h>struct ZFSZ //定义指针类型{int chardata;struct ZFSZ*next;};#define LEN sizeof(struct ZFSZ)#define N 10char c[N]={'t','a','n','k','k','*','y','o','u'}; //字符数组定义，保存字符“tankk+you”struct ZFSZ* creat() //函数一：建立链表{int a;struct ZFSZ *head;struct ZFSZ *p1,*p2;a=0;p1=(struct ZFSZ*)malloc(LEN);p1->chardata=c[0];while(p1->chardata!=NULL){a=a+1;if(a==1){head=p1;}else{p2->next=p1;}p2=p1;p1=(struct ZFSZ*)malloc(LEN);p1->chardata=c[a];}p2->next=NULL;return(head);}void Print (ZFSZ*head) //函数二：建立打印程序，输出链表中的内容{struct ZFSZ*Pp1,*Phead;Phead=head;Pp1=head;while (Pp1!=NULL&&Pp1->chardata!=0){printf("%c",Pp1->chardata);Pp1=Pp1->next;}printf("\n");}void Dell(ZFSZ*head) //函数三：删除第四个元素{struct ZFSZ*Dp1,*Dp2,*Dhead;Dhead=head;int n=1;for(n;n<=4;n++){if(n==3){Dp1=Dhead;}if(n==4){Dp2=Dhead->next;}Dhead=Dhead->next;}free(Dp1->next);Dp1->next=Dp2;}void ChaRu(struct ZFSZ*head) //函数四：再第二个元素前插入字符‘h’{struct ZFSZ*Cp1,*Cp2,*Chead;Chead=head;int m=1;for(m;m<=2;m++){if(m==1){Cp1=Chead;}Cp2=Chead->next;}Chead=(struct ZFSZ*)malloc(LEN);scanf("%c",&Chead->chardata);Cp1->next=Chead;Chead->next=Cp2;}int main() //主函数{struct ZFSZ *head; //调用函数一，建立链表head = creat();Print(head); //调用函数二输出链表中的内容Dell(head); //调用函数三：删除第四个元素Print(head); //调用函数二输出链表中的内容ChaRu(head); //调用函数四：再第二个元素前插入字符‘h’Print(head); //调用函数二输出链表中的内容}1.4 实验结果。

单链表的插入和删除实验报告

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

二、要求：建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。

单链表的插入和删除实验报告

单链表的基本操作实验报告

数据结构单链表插入、删除和修改实验报告

单链表的实验报告

数据结构单链表实验报告

数据结构C语言单链表上实现插入和删除的算法实验报告

单链表的实验报告总结

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告

单链表操作实验报告

单链表的操作实验报告

单链表地插入和删除实验报告材料

实验二 单链表的插入和删除

单链表的操作实验报告

单链表实验总结

数据结构单链表实验报告

单链表的插入和删除

单链表的插入和删除实验报告

实验二单链表的插入和删除