实验四单链表及其应用(参考程序)

合集下载

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

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

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

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

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

二、实验过程1. 创建链表首先，我们需要创建一个空链表。

链表可以通过一个头节点来表示，头节点不存储数据，只用于标识链表的起始位置。

我们可以定义一个指针变量head，将其指向头节点。

2. 插入节点在链表中插入节点是常见的操作。

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

插入节点的过程可以分为以下几个步骤：a. 创建一个新节点，并为其赋值；b. 找到要插入位置的前一个节点；c. 将新节点的指针指向前一个节点的下一个节点；d. 将前一个节点的指针指向新节点。

3. 删除节点删除节点是另一个常见的操作。

我们可以选择删除链表的头节点、尾节点或者指定位置的节点。

删除节点的过程可以分为以下几个步骤：a. 找到要删除节点的前一个节点；b. 将前一个节点的指针指向要删除节点的下一个节点；c. 释放要删除节点的内存空间。

4. 遍历链表遍历链表是为了查看链表中的元素。

我们可以从头节点开始，依次访问每个节点，并输出节点的值。

三、实验结果在本次实验中，我们成功完成了单链表的基本操作。

通过创建链表、插入节点、删除节点和遍历链表等操作，我们可以方便地对链表进行增删改查操作。

四、实验总结通过本次实验，我们对单链表的基本操作有了更深入的了解。

单链表是一种非常重要的数据结构，广泛应用于各个领域。

掌握了单链表的基本操作，我们可以更好地解决实际问题，并且为以后学习更复杂的数据结构打下坚实的基础。

在实验过程中，我们还发现了一些问题和不足之处。

单链表的实验报告

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

在本次实验中，我们将学习如何使用单链表来实现一些基本的操作，并通过实验验证其功能和效率。

一、实验目的本次实验的主要目的是掌握单链表的基本概念和操作方法，包括插入、删除、查找等操作，并通过实际操作来验证其正确性和效率。

二、实验过程1. 单链表的定义和初始化首先，我们需要定义一个单链表的结构，并初始化一个空链表。

链表的结构可以使用C语言中的结构体来表示，其中包含一个数据域和一个指向下一个节点的指针。

2. 插入操作在已有链表中插入一个新的节点，可以分为两种情况：在链表头部插入和在链表中间插入。

我们可以通过修改指针的指向来实现插入操作。

3. 删除操作删除链表中的一个节点，同样可以分为两种情况：删除头节点和删除中间节点。

删除操作需要注意指针的重新连接，以防止链表断裂。

4. 查找操作在链表中查找指定的元素，可以通过遍历链表的方式来实现。

从链表头开始，依次比较节点的数据域，直到找到目标元素或者遍历到链表尾部。

5. 其他操作在实际应用中，还可以对链表进行排序、逆序、合并等操作，这些操作都可以通过适当的算法来实现。

三、实验结果通过实际操作，我们验证了单链表的各种操作方法的正确性和效率。

在插入、删除和查找操作中，链表的时间复杂度为O(n)，其中n为链表的长度。

而在其他操作中，时间复杂度则根据具体算法的实现方式而定。

四、实验总结通过本次实验，我们深入了解了单链表的结构和操作方法，并通过实际操作来验证了其功能和效率。

单链表作为一种常用的数据结构，在实际应用中具有广泛的用途，例如链表可以用来实现栈、队列等其他数据结构，也可以用于解决一些实际问题，如链表的反转、环的检测等。

总之，掌握单链表的基本概念和操作方法对于学习和理解数据结构具有重要意义。

通过实验的方式，我们不仅能够加深对单链表的理解，还能够提高编程能力和解决实际问题的能力。

数据结构实验报告--单链表

数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式，深入了解单链表的数据结构以及相关操作，提升对数据结构的理解和应用能力。

1.2 实验内容本实验主要包括以下几个方面的内容：●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含数据和指向下一个节点的指针。

2.2 单链表的基本操作①单链表的插入操作在单链表中，可以通过插入操作在指定位置插入一个新节点，该操作主要包括以下步骤：●创建一个新的节点，并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中，可以通过删除操作删除指定位置的节点，该操作主要包括以下步骤：●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点，并执行相应的操作。

④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。

⑤单链表的查找操作在单链表中，可以通过查找操作找到指定值的节点。

⑥单链表的修改操作在单链表中，可以通过修改操作修改指定位置的节点的值。

3.实验过程3.1 实验环境本次实验使用C语言进行编程，需要先安装相应的编程环境，如gcc编译器。

3.2 实验步骤①单链表的创建和初始化首先创建一个空链表，并初始化链表的头指针。

②单链表的插入操作按照需求，在链表的指定位置插入一个新节点。

③单链表的删除操作按照需求，删除链表中的指定位置的节点。

④单链表的遍历操作依次访问链表中的每一个节点，并输出其值。

⑤单链表的逆置操作将单链表中的节点顺序进行逆置。

⑥单链表的查找操作按照需求，在链表中查找指定值的节点。

3.2.7 单链表的修改操作按照需求，修改链表中指定位置的节点的值。

实验四链表

实验二链表的基本操作一、实验目的掌握链表的基本概念、结构的定义，通过设计程序掌握链表上的基本操作：建立、插入、删除、查找以及链表合并等，并理解线性表的两种存储结构：顺序表和链表的区别。

二、实验准备1. 复习C语言中指针的用法，特别是结构体的指针的用法。

2. 了解链表（含带头结点的链表、循环链表）的概念，链表的结构定义方法。

单链表是线性表的链式存储表示，是用一组任意的存储单元依次存储线性表的数据元素。

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

3. 掌握线性表在链式存储结构上实现基本操作：建立、查找、插入、删除等算法。

在实现这些算法的时候，要注意判断输入数据的合法性，除此之外还要要注意以下内容：✧在实现查找的时候，首先要判断该顺序表是否为空，其次要判断查找后的结果(查到时输出查到的数据，未查到时给出相关提示)。

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

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

例如：删除如上图所示s所指向的结点p->next=p->next->next；free(s);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;}三、实验内容1. /*函数link()的功能是将带头结点的单链表l2链接到l1的后面，程序中存在几处错误，请改正并调试运行*/#include "linklist.h"void link(linklist l1,linklist l2){linklist p,q;p=l1;while (p->next)p=q->next;q=l2;p->next=q;free(l2);}void main(){ linklist l1,l2;l1=creat2(); /*生成带头结点的单链表l1*/print(l1); /*输出单链表l1*/l2=creat2(); /*生成带头结点的单链表l2*/print(l2); /*输出单链表l2*/link(l1,l2); /*将单链表l2链接到l1的后面*/print(l1); /*输出单链表l1*/}2./* 编写一个函数perm,将带头结点单链表中的所有值为奇数的结点集中到链表的左边，值为偶数的结点集中到链表的右边*/#include "linklist.h"linklist perm(linklist head){linklist pre,p;pre=head;p=head->next;while (p && p->data%2==1){ pre= p ;p= p->next ;}while (p){ if (p->data%2==1){ pre->next=p->next;p->next=head->next;head->next=p;p=pre->next;}else{ pre=p;p=p->next;}}}/*主函数,请勿改动,请将perm中的函数补充完整*/int main(){ linklist head;head=creat2(); /*尾插法建立单链表*/print(head); /*输出单链表head*/perm(head);print(head);delList(head);return 0;}3.设计程序：/*建立一个带头结点的单链表，然后将该链表进行倒置。

单链表的操作实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验报告单链表

数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的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.实验结果：通过运行上述代码，我们可以看到单链表的基本操作得到了实现。

单链表在实际程序中的使用

单链表在实际程序中的使用
单链表（Single Linked List）是一种常用的数据结构，它在许多实际程序中都有广泛的应用。

以下是一些常见的使用场景：
1. 动态数组：单链表可以作为动态数组的替代方案。

由于数组的大小在创建时就已经确定，如果要添加或删除元素，可能需要复制整个数组。

而单链表提供了动态添加和删除元素的能力，因此更适合需要频繁添加和删除元素的场景。

2. 历史记录或日志：单链表可以用来存储历史记录或日志。

每个节点可以包含一个事件或消息，以及指向下一个节点的指针。

这种方式可以方便地按顺序访问所有的事件或消息。

3. 文件系统：在文件系统中，目录结构可以用单链表来表示。

每个节点可以代表一个目录或文件，以及其子目录或文件的指针。

4. 图形和树形结构：单链表也可以用于表示图形和树形结构。

每个节点可以表示一个顶点或节点，而指针可以表示边或父-子关系。

5. 实现数据持久化：在需要将数据存储在磁盘或数据库中时，单链表可以作为一种实现数据持久化的方式。

每个节点可以包含一个数据项和一个指向下一个节点的指针，这样可以方便地将整个链表序列化为一个连续的字节流，然后存储在磁盘上。

6. 缓存和LRU算法：单链表也可以用于实现缓存和LRU（最近最少使用）算法。

在这种场景下，每个节点可以表示一个缓存项，包含数据和指向下一个节点的指针。

当缓存满时，最近最少使用的缓存项可以从链表中删除。

以上是一些常见的使用场景，实际上，单链表在许多其他领域也有广泛的应用，例如在算法、数据结构、操作系统、编译器设计等领域中都可以看到单链表的身影。

单链表的操作实验报告

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

在本次实验中，我们将学习如何使用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);```四、单链表的查找操作查找操作是在单链表中查找指定数据的节点。

单链表操作实验报告

线性表一、实验目的1. 了解线性表的逻辑结构特征，以及这种特性在计算机内的两种存储结构。

2. 掌握线性表的顺序存储结构的定义及其C语言实现。

3. 掌握线性表的链式村粗结构——单链表的定义及其C语言实现。

4. 掌握线性表在顺序存储结构即顺序表中的各种基本操作。

5. 掌握线性表在链式存储结构——单链表中的各种基本操作。

二、实验要求1. 认真阅读和掌握本实验的程序。

2. 上机运行本程序。

)3. 保存和打印出程序的运行结果，并结合程序进行分析。

4. 按照对顺序表和单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果三、实验内容请编写C程序，利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。

具体地说，就是要根据键盘输入的数据建立一个单链表，并输出该单链表；然后根据屏幕菜单的选择，可以进行数据的插入或删除，并在插入或删除数据后，再输出单链表；然后在屏幕菜单中选择0，即可结束程序的运行。

四、解题思路本实验要求分别写出在带头结点的单链表中第i（从1开始计数）个位置之后插入元素、创建带头结点的单链表中删除第i个位置的元素、顺序输出单链表的内容等的算法。

五、程序清单#include<>#include<>#include<>typedef int ElemType;~typedef struct LNode{ ElemType data;struct LNode *next;}LNode;LNode *L;LNode *creat_L();void out_L(LNode *L);void insert_L(LNode *L,int i,ElemType e);ElemType delete_L(LNode *L,int i);int locat_L(LNode *L,ElemType e);$void main(){ int i,k,loc;ElemType e,x;char ch;do{ printf("\n");printf("\n 1.建立单链表");printf("\n 2.插入元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运行");.printf("\n======================================");printf("\n 请输入您的选择（1，2，3，4，0）");scanf("%d",&k);switch(k){ case 1:{ L=creat_L();out_L(L);}break;case 2:{ printf("\n请输入插入位置：");scanf("%d",&i);printf("\n请输入要插入元素的值：");scanf("%d",&e);&insert_L(L,i,e);out_L(L);}break;case 3:{ printf("\n请输入要删除元素的位置：");scanf("%d",&i);x=delete_L(L,i);out_L(L);if(x!=-1){printf("\n删除的元素为：%d\n",x);printf("删除%d后的单链表为：\n",x);out_L(L);|}else printf("\n要删除的元素不存在！");}break;case 4:{ printf("\n请输入要查找的元素值：");scanf("%d",&e);loc=locat_L(L,e);if(loc==-1) printf("\n为找到指定元素！"); else printf("\n已找到，元素位置是%d",loc);}break;}printf("\n----------------");)}while(k>=1&&k<5);printf("\n 按回车键，返回...\n");ch=getchar();}LNode *creat_L(){ LNode *h,*p,*s; ElemType x;h=(LNode *)malloc(sizeof(LNode));h->next=NULL;p=h;printf("\n请输入第一个数据元素：");,scanf("%d",&x);while(x!=-999){ s=(LNode *)malloc (sizeof(LNode));s->data=x; s->next=NULL;p->next=s; p=s;printf("请输入下一个数据：（输入-999表示结束。

数据结构单链表实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

单链表实验报告

单链表实验报告单链表的基本操作1.实验题目问题描述：实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。

通过代码的编写理解并掌握单链表的过程编写以及作用。

2.实验要求（1）依次从键盘读入数据，建立一个单链表并将单链表的初始化设置为空；（2）通过操作选择，输出单链表中的数据元素（3）显示单链表的长度；（4）根据指定条件能够查找出元素和修改元素；（5）实现在指定位置插入和删除元素的功能（6）显示操作后的结果3.算法设计（1）用到的结构（逻辑结构、存储结构）逻辑结构：线性结构存储结构：带头结点的单链表（2）算法设计思路定义结点类型LNode，每个结点包括数据域data和指针域next。

定义头指针LinkList。

编写如下函数：1、createlist(LinkList &L)；用尾插法创建一个带头结点的单链表。

2、print(LinkList L)；输出该单链表中的数据元素。

3、ListLength(LinkList L)；求该单链表的长度。

4、GetElem(LinkList &L,int i,ElemType &e)；查找第i个元素。

5、SetElem(LinkList &L,int i,ElemType m)；修改第i个元素。

6、ListInsert (LinkList &L, int i, ElemType e )；在第i个元素前插入一个元素。

7、ListDelete(LinkList &L,int i,ElemType &e2)；删除第i个元素。

8、main()；通过case结构来调用createlist(LinkList &L)、GetElem(LinkList&L,int i,ElemType &e)、SetElem(LinkList &L,int i,ElemType m)、ListInsert (LinkList &L, int i, ElemType e )、ListDelete(LinkList &L,int i,ElemType &e2)4.调试和测试调试过程总结经过多次调试，本程序能很好的完成实验要求的各项功能。

单链表实验报告

单链表实验报告第一篇：单链表实验报告《数据结构》实验报告二分校：学号：日期：班级：姓名：程序名： L2311.CPP一、上机实验的问题和要求：单链表的查找、插入与删除。

设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。

具体实现要求：1.从键盘输入20个整数，产生带表头的单链表，并输入结点值。

2.从键盘输入1个整数，在单链表中查找该结点。

若找到，则显示“找到了”；否则，则显示“找不到”。

3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。

4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。

5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。

6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。

7.把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。

8.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。

二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）三、源程序及注释：四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：六、对算法的程序的讨论、分析，改进设想，其它经验教训：七、对实验方式、组织、设备、题目的意见和建议：第二篇：北邮数据结构实验报告单链表北京邮电大学数据结构试验报告实验名称：实验一线性表学生姓名：班级：班内序号：学号：日期： 2014年1月3日实验目的⌝熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法⌝学习指针、模板类、异常处理的使用⌝掌握线性表的操作的实现方法⌝学习使用线性表解决实际问题的能力实验内容2.1题目1 根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。

数据结构-单链表实验报告

数据结构-单链表实验报告数据结构单链表实验报告一、实验目的本次实验的主要目的是深入理解和掌握单链表这一数据结构的基本概念、操作原理以及在实际编程中的应用。

通过编写和调试相关程序，提高对数据结构的理解和编程能力，培养解决实际问题的思维和方法。

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

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

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

通过这种方式，节点依次连接形成链表。

单链表的基本操作包括创建链表、插入节点、删除节点、查找节点、遍历链表等。

在实现这些操作时，需要特别注意指针的操作，避免出现空指针异常和内存泄漏等问题。

四、实验内容（一）创建单链表创建单链表的过程就是依次为每个节点分配内存空间，并将节点连接起来。

以下是创建单链表的代码实现：｀｀｀cppinclude ＜iostream>using namespace std;／／定义链表节点结构体struct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；／／创建单链表ListNode 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;｝｀｀｀（二）插入节点插入节点可以分为在表头插入、在表尾插入和在指定位置插入三种情况。

实验四单链表及其应用(参考程序)

实验四单链表的建立一、实验目的1.掌握线性表的链式存储结构——单链表的定义及C 语言实现。

2.掌握线性表在链式存储结构——单链表中的各种基本操作。

二、实验内容1. 建立一个带头结点的单链表，结点的值域为整型数据。

要求将用户输入的数据分别按尾插入法和头插法来建立相应单链表。

【知识要点】为了便于实现各种运算，通常在单链表的第一个结点前增设一个附加结点，称为头结点，它的结构与表结点相同，其数据域可不存储信息，也可存储表长等附加信息，具体如下图。

【实验提示】单链表的结点结构除数据域外，还含有一个指针域。

用C 语言描述结点结构如下：typedef int datatype; /* 线性表中存放整型元素 */typedef struct LNode / * 结点类型定义 * /{datatype data; / * 数据域 * /struct node *next; / * 指针域 * / }Linklist ； /* Linklist 为单链表类型*/注意结点的建立方法及构造新结点时指针的变化。

构造一个结点需用到C语言的标准函数malloc()，如给指针变量p分配一个结点的地址：p=( strcut LNode *)malloc(sizeof(Linklist));该语句的功能是申请分配一个类型为Linklist的结点的地址空间，并将首地址存入指针变量p中(或p=new(struct LNode) ;即生成新结点)。

当结点不需要时可以用标准函数free(p)释放结点存储空间，这时p为空值（NULL）。

【程序提示】#include<stdio.h>typedef struct LNode{//补充实现表节点类型的定义；} Linklist;Linklist * creatlist(){ int x;Linklist *head, *p; // head为单链表的头指针，p指向新建的结点//补充实现单链表的建立；return(head); // 函数返回链表头指针head}void output(Linklist *HeadL){if(HeadL->next==NULL) printf("空链表!\n");else{printf("链表为：\n");Linklist *P;P=HeadL->next;while(P!=NULL){printf("%d->",P->data);P=P->next;}printf("\n");}}void main(void){Linklist *List;List=creatlist( );output(List);}【参考程序】1、尾插法#include<stdio.h>typedef struct LNode{int data;struct LNode *next;} Linklist;Linklist * creatlist(){ int x;Linklist *head, *p,*r; /* head为头指针*/head=new(struct LNode);head->data=0; /* 表头结点数据域赋值*/r=head; /* 尾指针的初值为头结点head */printf("请随机输入互不相同的正整数以0作为结束符:\n");scanf("%d", &x); /* 读入第一个结点的值*/while (x!=0) /* 输入数据，以0为结束符*/{ p=new(struct LNode); /* 生成新结点*/p->data=x; /* 给新结点的数据域赋值*/r->next=p; /* 新结点插入到表尾*rear之后*/r=p; /* 将尾指针rear指向新的尾结点*/head->data++; /* 链表长度计数*/scanf("%d", &x); /* 输入下一个结点的数据*/ }r->next=NULL;/* 将链表最后一个结点rear指针域置空*/ return(head); /* 函数返回链表头指针head */}void output(Linklist *HeadL){if(HeadL->next==NULL) printf("空链表!\n");else{printf("链表为：\n");Linklist *P;P=HeadL->next;while(P!=NULL){printf("%d->",P->data);P=P->next;}printf("\n");}}void main(void){Linklist *List;List=creatlist( );output(List);}2、头插法#include<stdio.h>typedef struct LNode{int data;struct LNode *next;} Linklist;Linklist * creatlist(){ int x;Linklist *head, *p; /* head为头指针*/head=new(struct LNode);head->data=0; /* 表头结点数据域赋值*/head->next=NULL;printf("\n请随机输入一组正整数以0结束输入:\n");scanf("%d",&x); /* 输入第一个结点数据值*/ while (x!=0) /* 输入数据，以0为结束符*/ { p=new(struct LNode); /* 生成新结点*/p->data=x; /* 给新结点的数据域赋值*/p->next=head->next;/* 将新结点插入表头结点head之后*/ head->next=p;head->data++; /* 链表长度计数*/scanf("%d",&x); /* 输入下一个结点的值*/}return(head); /* 函数返回链表头指针head */}void output(Linklist *HeadL){}void main(void){Linklist *List;List=creatlist( );output(List);}方法二void main(void){Linklist *head,*p;head=creatlist();printf("output the list:\n");p=head->next;while(p){printf("%d ",p->data);p=p->next;}}2. 在第一题的基础上，增加单链表的查找，插入，删除子程序。

实验4单链表的应用

struct LNode{
int num;
struct LNode *next;
};
LNode *p,*r,*list;
void Josephu(%d个人报数，上限为%d \n",n,m);
int i;
for(i=1;i<=n;i++)
{p = new LNode;
方面欠缺很能够正确的定我将进一步我相信在以很大主要是定义和使用步强化对c以后的学习是多c和c用指针造成的学习认过程中我c的掌握不成最后在调用认真复习指针我会越学越不够透用函数针相关越好
数据结构算法专题实验报告
实验名称：单链表的应用评分：________
班级：计科1602班学号：201610333姓名：石博洋
printf("%d ",p->num);
delete(p);
p=r->next;
}
printf("\n最后留下的是：%d\n",p->num);
}
int main(){
Josephu(15,3);
Josephu(20,5);
return 0;
}
实验程序执行结果：
实验过程中出现的问题及解决方法：
实验过程中,明显感到自己在编程方面欠缺很大,主要是多C和C++的掌握不够透彻,以至于在编写程序的过程中,不能够正确的定义和使用指针,造成最后在调用函数的时候出现了错误,在今后的学习中,我将进一步强化对C的学习,认真复习指针相关的知识，单链表相对来说比较简单，我相信在以后的学习过程中，我会越学越好。
实验内容：
约瑟夫环问题。有n个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人又出列，如此下去，直到所有人都出列为止。试设计确定他们出列次序的程序。要求选择单向循环链表作为存储结构模拟整个过程，并依次输出出列人的编码。

实验四单链表的基本操作

/*在带头结点的单链表head的数据元素ai（0≤i≤size）结点前*/
/*插入一个存放数据元素x的结点*/
{
SLNode *p, *q;
int j;
p = head;/*p指向首元结点*/
j = -1;/*j初始为-1*/
while(p->next != NULL && j < i - 1)
/*最终让指针p指向数据元素ai-1结点*/
3、删除上述单链表中指定位置的元素。
以下是程序部分代码，请调试并补充使之正确运行：
１．LinList.h
typedef struct Node
{
DataType data;
struct Node *next;
} SLNode;
void ListInitiate(SLNode *head)/*初始化*/
/*在带头结点的单链表head的数据元素ai（0 ≤ i ≤ size）结点前*/
/*插入一个存放数据元素x的结点*/
{
SLNode *p, *q;
int j;
p = head;/*p指向首元结点*/
j = -1;/*j初始为-1*/
while(p->next != NULL && j < i - 1)
/*head为头指针, x为要查找的数 */
{
SLNode *p=head;
int i=0;
while (p->next!=NULL)
{
if (p->data==x)
{
return i;
}
p=p->next;
i++;
}
if(p->data==x)

链表的基本操作数据结构实验报告记录

链表的基本操作数据结构实验报告记录————————————————————————————————作者：————————————————————————————————日期：大学数据结构实验报告课程名称数据结构实验第（四）次实验实验名称链表的基本操作学生姓名于歌专业班级学号实验成绩指导老师（签名）日期2018年10月01日一、实验目的1. 学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。

2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。

二、实验要求1．预习C语言中结构体的定义与基本操作方法。

2．对单链表的每个基本操作用单独的函数实现。

3．编写完整程序完成下面的实验内容并上机运行。

4．整理并上交实验报告。

三、实验内容：1．编写程序完成单链表的下列基本操作：（1）初始化单链表La（2）在La中插入一个新结点（3）删除La中的某一个结点（4）在La中查找某结点并返回其位置（5）打印输出La中的结点元素值（6）清空链表（7）销毁链表2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。

四、思考与提高：1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？五、实验设计1．编写程序完成单链表的下列基本操作：（1）初始化单链表LaLinkList InitList(){int i,value,n;LinkList H=(LinkList)malloc(sizeof(LNode));LinkList P=H;P->next=NULL;do{printf("请输入链表的长度:");scanf("%d",&n);if(n<=0)printf("输入有误请重新输入！\n");}while(n<=0);printf("请输入各个元素:\n");for(i=0; i<n; i++){scanf("%d",&value);LinkList NEW = (LinkList)malloc(sizeof(LNode)); NEW->data=value;P->next=NEW;NEW->next=NULL;P=NEW;}printf("链表建立成功！\n");return H->next;}（2）在La中插入一个新结点LinkList InsertList(LinkList L,int i,ElemType value) {LinkList h,q,t=NewLNode(t,value);int x=0;h=q=L;if(i==1)t->next=h, h=t;else{while(x++<i-2)q=q->next;t->next=q->next;q->next=t;}printf("插入成功！\n");return h;}（3）删除La中的某一个结点LinkList DeleteList(LinkList L,int i){LinkList h,q,de;int x=0;h=q=L;int t;if(i==1)h=h->next;else{while(x++<i-2)q=q->next;de=q->next;if(de->next==NULL)q->next=NULL;elseq->next=de->next;}printf("删除成功！\n");return h;}（4）在La中查找某结点并返回其位置Status LocateList(LinkList L,ElemType value){LinkList q=L;int i=0,t;while(q!=NULL){i++;if(q->data==value){printf("该结点在链表中的位置为第%d个\n",i); return OK;}q=q->next;}printf("该链表中没有该结点！\n");return ERROR;}（5）打印输出La中的结点元素值Status Print(LinkList L){LinkList q=L;printf("该链表的每个元素为:\n");while(q!=NULL){printf("%8d",q->data);q=q->next;}printf("\n");return OK;}（6）清空链表LinkList EmptyList(LinkList L){free(L->data);L->next=NULL;printf("清空成功！\n");return L;}（7）销毁链表LinkList FreeList(LinkList L){printf("释放成功！\n");free(L);}（8）主函数int main(){LinkList L=InitList();int n,i,j;Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:printf("请输入要插入的结点的值和插入的位置:"); scanf("%d %d",&i,&j);InsertList(L,j,i);break;case 2:printf("请输入要删除的结点的位置:");scanf("%d",&i);DeleteList(L,i);break;case 3:printf("请输入要查找的结点的值:");scanf("%d",&i);LocateList(L,i);break;case 4:Print(L);break;case 5:EmptyList(L);break;case 6:FreeList(L);break;}Pr();scanf("%d",&n);}if(n==7)printf("退出成功！");return 0;}2．构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表LcLinkList ConnectList(LinkList La,LinkList Lb){LinkList Lc,a,b,c;a=La;b=Lb;if(La->data<Lb->data)Lc=La,a=a->next;elseLc=Lb,b=b->next;c=Lc;while(a!=NULL||b!=NULL){if(a==NULL)c->next=b,break;if(b==NULL)c->next=a;break;if(a->data<b->data)c->next=a,a=a->next,c=c->next;elsec->next=b,b=b->next,c=c->next;return Lc;}3．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作LinkList ConnectList(LinkList La,LinkList Lb){int i=1;LinkList Lc,a,b,c,q,p;a=La;b=Lb;if(La->data<Lb->data)Lc=La;a=a->next;elseLc=Lb;b=b->next;c=Lc;while(a!=NULL||b!=NULL){if(a==NULL)c->next=b，break;if(b==NULL)c->next=a，break;if(a->data<b->data)c->next=a，a=a->next，c=c->next;elsec->next=b，b=b->next，c=c->next;}c=Lc;q=c->next;while(q!=NULL){if(c->data==q->data){c->next=q->next;}c=c->next;q=c->next;}return Lc;}4．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？Status PartList(LinkList Lc){int n1=0,n2=0;LinkList La,Lb,L;LinkList a,b;L=Lc;while(L!=NULL){if(L->data%2==0){if(n1==0){a=La=L;L=L->next;}else{a->next=L;L=L->next;}}else{if(n2==0){b=Lb=L;L=L->next;}else{b->next=L;L=L->next;}}}a->next=NULL;b->next=NULL;return OK;}六、实验测试1．编写程序完成单链表的下列基本操作：七、总结附录1：源代码#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType;typedef int Status;typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList NewLNode(LNode *P,ElemType data){P = (LNode *)malloc(sizeof(LNode));P->data = data;P->next = NULL;return P;}LinkList InitList(){int i,value,n;LinkList H=(LinkList)malloc(sizeof(LNode));LinkList P=H;P->next=NULL;do{printf("请输入链表的长度:");scanf("%d",&n);if(n<=0)printf("输入有误请重新输入！\n");}while(n<=0);printf("请输入各个元素:\n");for(i=0; i<n; i++){scanf("%d",&value);LinkList NEW = (LinkList)malloc(sizeof(LNode)); NEW->data=value;P->next=NEW;NEW->next=NULL;P=NEW;}printf("链表建立成功！\n");return H->next;}LinkList InsertList(LinkList L,int i,ElemType value) {LinkList h,q,t=NewLNode(t,value);int x=0;h=q=L;if(i==1){t->next=h;h=t;}else{while(x++<i-2)q=q->next;t->next=q->next;q->next=t;}printf("插入成功！\n");return h;}LinkList DeleteList(LinkList L,int i){LinkList h,q,de;int x=0;h=q=L;int t;if(i==1)h=h->next;else{while(x++<i-2)q=q->next;de=q->next;if(de->next==NULL)q->next=NULL;elseq->next=de->next;}printf("删除成功！\n");return h;}Status LocateList(LinkList L,ElemType value){LinkList q=L;int i=0,t;while(q!=NULL){i++;if(q->data==value){printf("该结点在链表中的位置为第%d个\n",i); return OK;}q=q->next;}printf("该链表中没有该结点！\n");return ERROR;}Status Print(LinkList L){LinkList q=L;printf("该链表的每个元素为:\n");while(q!=NULL){printf("%8d",q->data);q=q->next;}printf("\n");return OK;}LinkList EmptyList(LinkList L){free(L->data);L->next=NULL;printf("清空成功！\n");return L;}LinkList FreeList(LinkList L){printf("释放成功！\n");free(L);}void Pr(){printf("\n1.插入新结点\n");printf("2.删除链表中的结点\n");printf("3.查找结点\n");printf("4.输出链表\n");printf("5.清空链表\n");printf("6.销毁链表\n");printf("7.退出\n");printf("请输入要使用的功能:");}int main(){LinkList L=InitList();int n,i,j;Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:printf("请输入要插入的结点的值和插入的位置:"); scanf("%d %d",&i,&j);InsertList(L,j,i);break;case 2:printf("请输入要删除的结点的位置:");scanf("%d",&i);DeleteList(L,i);break;case 3:printf("请输入要查找的结点的值:");scanf("%d",&i);LocateList(L,i);break;case 4:Print(L);break;case 5:EmptyList(L);break;case 6:FreeList(L);break;}Pr();scanf("%d",&n);}if(n==7)printf("退出成功！"); return 0;}。

单链表的实现与应用原理

单链表的实现与应用原理1. 单链表的定义及基本操作单链表是一种线性数据结构，由一系列结点组成，每个结点包含一个数据元素和一个指向下一个结点的指针。

单链表中的结点只能通过指针进行访问，而不能直接访问前一个结点。

基本的操作包括： - 创建单链表 - 插入结点 - 删除结点 - 查找结点 - 遍历单链表2. 单链表的创建创建一个空的单链表可以使用以下步骤：1. 声明一个头指针，初始化为NULL。

2. 根据需求动态申请内存，创建一个结点并将数据存储于其中。

3. 将头指针指向创建的结点。

3. 单链表的插入3.1 头插法头插法是指将新结点插入到单链表的表头位置。

插入操作包括以下步骤： 1. 创建新结点，将数据存储于其中。

2. 将新结点的指针指向原头结点。

3. 将头指针指向新结点。

3.2 尾插法尾插法是指将新结点插入到单链表的表尾位置。

插入操作包括以下步骤： 1. 创建新结点，将数据存储于其中。

2. 遍历单链表，找到最后一个结点。

3. 将最后一个结点的指针指向新结点。

4. 单链表的删除删除单链表中的一个结点需要注意以下几点：- 找到待删除结点的前一个结点，将其指针指向待删除结点的下一个结点。

- 释放待删除结点的内存空间。

5. 单链表的查找可以通过遍历单链表的方式查找特定的结点。

遍历操作包括以下步骤： 1. 从头结点开始，逐个向下访问结点。

2. 若结点的数据与目标数据相等，则找到目标结点。

3. 若遍历至链表末尾仍未找到目标结点，则表示目标结点不存在。

6. 单链表的应用原理单链表的应用非常广泛，主要体现在以下几个方面：6.1 数据存储单链表可以动态地存储数据，避免了静态数组需要预先分配固定大小空间的限制。

通过插入和删除结点的操作，可以灵活地存储和管理各种类型的数据。

6.2 数据结构单链表是许多其他数据结构的基础，例如栈、队列和图等。

通过将结点的指针指向后继结点，可以构建出各种复杂的数据结构。

6.3 算法实现许多常见的算法问题可以通过单链表来解决，例如反转链表、合并链表和判断链表是否存在环等。

单链表的各种基本运算的实现实验报告

软件技术基础实验一——单链表的各种基本运算的实现一、实验题目编写一个程序，实现单链表的各种基本运算，并在此基础上设计一个主程序完成如下功能：（1）初始化单链表（2）依次采用尾插法插入a,b,c,d,e元素（3）输出单链表（4）在第四个元素位置上插入f元素（5）删除该单链表的第三个元素二、实验目的1、理解单链表的概念及结构特点；2、掌握单链表的基本操作：查找、插入、删除等运算在链接存储结构上的运算。

三、调试通过并正确执行给定功能要求的实验代码#include "stdafx.h"#include<malloc.h>#include<iostream.h>struct link{char data;link *next;};link *rcreat(link *head,char x) //尾插法建立单链表{link *s,*r;r=head;s=new link;s->data=x;r->next=s;r=s;r->next=NULL;return r;}link *get(link *head,int i) //查找第i个元素，返回其地址{int j;link *p;j=1;p=head->next ;while((j<i-1)&&(p!=NULL)){j++;p=p->next;}return p;}void insert(link *head,int num,char y) //元素y之后插入x {link *p,*s;s=new link;s->data=y;if(head->next==NULL){head->next=s;s->next=NULL;}p=get(head,num);if(p==NULL) cout<<"插入位置非法";else{s->next=p->next;p->next=s;}}void delet(link *head,char x) //将指定元素x删除{link * p, * q;q=head;p=head->next;while((p!=NULL)&&(p->data!=x)){q=p;p=p->next;}if(p==NULL) cout<<"要删除的元素不存在";else{q->next=p->next;delete(p);}}void print(link *head) //输出单链表{link *p;p=head->next;while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}void main(int argc, char* argv[]){link *head,*p,*q,*r;char x,y;int n,dele,i=1,j=1;head=new link;head->next=NULL;r=head;while(j<=5){cout<<"请输入要插入的元素：";cin>>x;r=rcreat(r,x);j=j+1;}print(head);cout<<"请输入要插入元素的位置：";cin>>n;cout<<"请输入要插入的元素：";cin>>y;insert(head,n,y);cout<<"输出插入后的单链表："<<endl;print(head);cout<<"请输入要删除元素的位置：";cin>>dele;q=head;p=head->next;while(i<dele){q=p;p=p->next;i=i+1;}q->next=p->next;delete (p);cout<<"删除后的链表如下："<<endl;print(head);}四、实验结果。

实验四 单链表及其应用(参考程序)

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

单链表的实验报告

数据结构实验报告--单链表

实验四 链表

单链表的操作实验报告

数据结构实验报告单链表

单链表在实际程序中的使用

单链表的操作实验报告

单链表操作实验报告

数据结构单链表实验报告

单链表实验报告

单链表实验报告

数据结构-单链表实验报告

实验四 单链表及其应用(参考程序)

实验4单链表的应用

实验四 单链表的基本操作

链表的基本操作数据结构实验报告记录

单链表的实现与应用原理

单链表的各种基本运算的实现 实验报告

实验四单链表及其应用(参考程序)

实验四链表

实验四单链表及其应用(参考程序)

实验四单链表的基本操作

单链表的各种基本运算的实现实验报告