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

合集下载

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

北工大实验报告

北工大实验报告

一、实验名称数据结构实验二:链表的基本操作二、实验目的1. 理解链表的基本概念和结构。

2. 掌握链表的创建、插入、删除、查找等基本操作。

3. 提高编程能力,巩固数据结构知识。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验原理链表是一种常见的线性数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表具有以下特点:1. 无固定长度,可以根据需要动态地添加或删除节点。

2. 链接方式灵活,便于实现各种操作。

3. 适合存储具有动态变化的数据。

本实验主要实现以下功能:1. 创建链表:根据用户输入的数据,创建一个单链表。

2. 插入节点:在链表的指定位置插入一个新节点。

3. 删除节点:删除链表中的指定节点。

4. 查找节点:在链表中查找一个指定的节点。

5. 打印链表:遍历链表并打印所有节点数据。

五、实验步骤1. 创建链表```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(nullptr) {}};ListNode createList() {ListNode head = nullptr, tail = nullptr;int data;cout << "请输入链表数据(输入-1结束):" << endl; while (cin >> data && data != -1) {ListNode node = new ListNode(data);if (head == nullptr) {head = node;tail = node;} else {tail->next = node;tail = node;}}return head;}```2. 插入节点```cppvoid insertNode(ListNode head, int data, int position) { ListNode node = new ListNode(data);if (position == 0) {node->next = head;head = node;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "插入位置超出链表长度!" << endl; return;}current = current->next;}node->next = current->next;current->next = node;}}```3. 删除节点```cppvoid deleteNode(ListNode head, int position) {if (head == nullptr) {cout << "链表为空!" << endl;return;}if (position == 0) {ListNode temp = head;head = head->next;delete temp;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "删除位置超出链表长度!" << endl; return;}current = current->next;}if (current->next == nullptr) {cout << "删除位置超出链表长度!" << endl;return;}ListNode temp = current->next;current->next = temp->next;delete temp;}}```4. 查找节点```cppListNode findNode(ListNode head, int data) { ListNode current = head;while (current != nullptr) {if (current->data == data) {return current;}current = current->next;}return nullptr;}```5. 打印链表```cppvoid printList(ListNode head) {ListNode current = head;while (current != nullptr) {cout << current->data << " ";current = current->next;}cout << endl;}```六、实验结果与分析通过以上步骤,成功实现了链表的基本操作。

数据结构实验报告实验5

数据结构实验报告实验5

数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构,如链表、栈、队列、树和图等,并通过实际编程实现,提高对数据结构的操作和应用能力。

同时,培养解决实际问题的思维和编程能力,提高代码的可读性、可维护性和效率。

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

三、实验内容1、链表的基本操作创建链表插入节点删除节点遍历链表2、栈的实现与应用用数组实现栈用链表实现栈栈的应用:括号匹配3、队列的实现与应用用数组实现队列用链表实现队列队列的应用:排队模拟4、二叉树的遍历前序遍历中序遍历后序遍历5、图的表示与遍历邻接矩阵表示法邻接表表示法深度优先遍历广度优先遍历四、实验步骤1、链表的基本操作创建链表:首先定义一个链表节点结构体,包含数据域和指向下一个节点的指针域。

然后通过动态内存分配创建链表节点,并将节点逐个连接起来,形成链表。

插入节点:根据插入位置的不同,分为在表头插入、在表尾插入和在指定位置插入。

在指定位置插入时,需要先找到插入位置的前一个节点,然后进行节点的连接操作。

删除节点:同样需要根据删除位置的不同进行处理。

删除表头节点时,直接将头指针指向下一个节点;删除表尾节点时,找到倒数第二个节点,将其指针置为空;删除指定位置节点时,找到要删除节点的前一个节点,然后调整指针。

遍历链表:通过从链表头开始,依次访问每个节点,输出节点的数据。

2、栈的实现与应用用数组实现栈:定义一个固定大小的数组作为栈的存储空间,同时用一个变量记录栈顶位置。

入栈操作时,先判断栈是否已满,如果未满则将元素放入栈顶位置,并更新栈顶位置;出栈操作时,先判断栈是否为空,如果不空则取出栈顶元素,并更新栈顶位置。

用链表实现栈:与链表的操作类似,将新元素添加在链表头部作为栈顶。

括号匹配:输入一个包含括号的字符串,使用栈来判断括号是否匹配。

遇到左括号入栈,遇到右括号时与栈顶的左括号进行匹配,如果匹配成功则出栈,否则括号不匹配。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。

实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。

利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第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指向的节点即为要删除的节点。

数据结构实验报告

数据结构实验报告

数据结构实验报告
本次数据结构实验的任务主要包括两部分,分别是学习使用链表数据结构和掌握链表排序算法。

在此基础上,我们完成了一组关于链表基本操作和排序算法的实验。

实验一:链表基本操作
在这个实验中,我们学习了链表的插入、删除、查找等基本操作。

链表的插入和删除操作是通过一个链表节点来实现的。

链表节点包括一个数据域和一个指向下一个节点的指针域。

通过修改指针域,我们就可以实现节点的插入和删除操作。

具体来说,我们编写了一个基本的链表程序,其中包括链表头指针初始化、链表节点插入、链表节点删除、查找指定节点等操作。

通过对程序的调试和功能测试,我们验证了链表操作的正确性。

实验二:链表排序算法
在这个实验中,我们学习了链表排序算法,并编写了链表的快速排序和归并排序两种算法。

快速排序是一种分治思想的排序算法,通过选择一个基准元素,分别将小于和大于基准元素的元素分别放在它的左右两边,再递归地对左右两个子序列进行排序,最终得到有序序列。

归并排序是另一种经典的排序算法,它利用归并思想,将两个有序序列合并成一个更大的有序序列,这个过程不断重复,最终得到完整的有序序列。

通过实现这两种排序算法,并在大样本数据下进行测试,我们验证了算法的正确性和效率。

实验总结:
通过本次实验,我们深入学习了链表数据结构的相关基本操作和排序算法的实现原理。

同时,在实际编程实践中,我们也掌握了链表程序的调试、测试和优化技术。

这些都是我们今后从事软件开发工作需要掌握的重要技能,在这个方面的积累将会对我们有很大帮助。

南邮数据结构实验三

南邮数据结构实验三

南邮数据结构实验三南京邮电大学数据结构实验三、链表的基本操作实验目的本次实验的主要目的是理解链表的概念,掌握链表的基本操作,包括链表的创建、插入、删除和遍历。

实验内容本次实验分为以下几个部分:1、链表的定义与创建1.1 链表的概念链表是一种常见的数据结构,由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表可以分为单链表、双链表和循环链表等不同类型。

本次实验将创建一个单链表。

1.2 链表节点的定义链表节点包含两个成员变量,分别是数据域和指针域。

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

1.3 链表的创建在主函数中创建一个空链表,并添加一些初始数据,用于后续的操作。

2、链表的插入操作2.1 插入节点的位置链表的插入操作需要指定节点插入的位置,可以在链表的头部、尾部或者中间插入新节点。

2.2 插入节点的操作根据所选位置,在链表中插入新节点,并更新相应的指针。

3、链表的删除操作3.1 删除节点的位置链表的删除操作需要指定节点删除的位置,可以删除头节点、尾节点或者中间节点。

3.2 删除节点的操作根据所选位置,删除链表中的节点,并更新相应的指针。

4、链表的遍历操作通过循环遍历链表的所有节点,并输出每个节点的数据。

附件说明本文档涉及以下附件:附件1:源代码附件2:实验报告法律名词及注释本文所涉及的法律名词及注释如下:1、数据结构:数据的存储方式和操作组成的集合。

在计算机科学中,数据结构是计算机中存储、组织数据的方式。

2、链表:链表是一种常见的数据结构,由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

3、节点:链表中的一个元素,包含数据域和指针域。

4、数据域:节点中存储的数据。

5、指针域:节点中指向下一个节点的指针。

6、插入操作:在链表中插入一个新节点。

7、删除操作:从链表中删除一个节点。

8、遍历操作:按照一定的顺序访问链表中的所有节点。

全文结束。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告范本:数据结构单链表实验报告一、引言本实验旨在掌握数据结构中单链表的基本概念、操作和应用。

通过实际操作,理解单链表的结构与实现,提高数据结构的编程能力和问题解决能力。

二、实验目的1. 理解单链表的概念和特点;2. 掌握单链表的基本操作,包括插入、删除、遍历;3. 学会使用单链表解决实际问题。

三、实验内容1. 单链表的定义和结构设计;2. 单链表的基本操作的实现,包括插入节点、删除节点、遍历;3. 针对具体的问题,设计相应的单链表操作。

四、实验步骤1. 单链表的定义和结构设计:(1)定义单链表的结构体,包含数据域和指针域;(2)实现单链表的初始化函数;(3)实现单链表的销毁函数。

2. 单链表的基本操作的实现:(1)实现单链表的插入节点操作;(2)实现单链表的删除节点操作;(3)实现单链表的遍历操作。

3. 针对具体问题的单链表操作:(1)根据具体需求,设计并实现相应的操作函数;(2)利用单链表解决具体问题。

五、实验结果与分析1. 在实验过程中,成功实现了单链表的定义和结构设计,包括数据域和指针域的正确设置。

2. 实验中实现了插入节点、删除节点和遍历等基本操作。

3. 针对具体问题,通过单链表操作解决了相应的问题。

六、实验总结通过本次实验,加深了对单链表的理解和掌握。

掌握了单链表的基本操作和应用实现,提高了数据结构的编程能力和问题解决能力。

附件:1. 本文所涉及的代码文件;2. 实验过程中所用到的数据文件。

法律名词及注释:1. 数据结构:指的是一组数据的表示方法和相应的操作。

在计算机科学中,数据结构是计算机中存储、组织数据的方式。

2. 单链表:是一种链式存储结构,每个节点包含数据域和指针域。

数据域用于存储数据,指针域用于指向下一个节点。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告一、实验目的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;}```头部插入时,创建新节点,将新节点的数据域赋值,并将其指针域指向原头节点的下一个节点,然后更新头节点的指针域指向新节点。

链表实验报告

链表实验报告

链表实验报告一、实验目的链表是一种常见的数据结构,本次实验的主要目的是深入理解链表的概念、原理和操作,通过实际编程实现链表的创建、插入、删除、遍历等基本操作,掌握链表在数据存储和处理中的应用,提高对数据结构的理解和编程能力。

二、实验环境本次实验使用的编程语言为 C 语言,开发工具为 Visual Studio Code。

三、实验原理链表是一种动态的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表的优点是可以灵活地进行插入和删除操作,不需要像数组那样移动大量的数据。

链表分为单向链表、双向链表和循环链表等。

单向链表只有一个指向下一个节点的指针,双向链表有指向前一个节点和后一个节点的指针,循环链表的尾节点指向头节点,形成一个环形结构。

四、实验步骤1、单向链表的创建定义链表节点结构体,包含数据域和指针域。

编写创建链表的函数,通过动态分配内存创建链表节点,并将节点连接起来。

2、单向链表的插入操作实现头部插入、尾部插入和中间插入的函数。

在插入时,需要处理指针的更新,确保链表的连接正确。

3、单向链表的删除操作编写删除指定节点的函数。

删除节点时,要释放被删除节点的内存,并更新相邻节点的指针。

4、单向链表的遍历实现遍历链表并打印节点数据的函数。

5、双向链表的创建与操作类似于单向链表,定义双向链表节点结构体,并实现创建、插入、删除和遍历的函数。

注意双向链表中指针的更新方式与单向链表的不同。

6、循环链表的创建与操作定义循环链表节点结构体,创建循环链表。

实现循环链表的插入、删除和遍历操作,处理好尾节点与头节点的连接。

五、实验结果与分析1、单向链表成功创建了单向链表,并能够正确进行头部、尾部和中间的插入操作。

删除操作也能准确删除指定节点,并释放内存。

遍历输出的结果与预期相符。

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.实验结果:通过运行上述代码,我们可以看到单链表的基本操作得到了实现。

链表的基本操作实验报告

链表的基本操作实验报告

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

链表相较于数组拥有更灵活的操作,能够动态地增删节点。

本实验旨在通过实际操作链表,加深对链表基本操作的理解和掌握。

实验目的:1. 理解链表的基本概念和结构;2. 学会链表的插入、删除和遍历操作;3. 掌握链表的相关算法。

实验过程:1. 创建链表首先,我们需要创建一个链表。

链表可以是单链表、双链表或循环链表,本次实验我们选择创建一个单链表。

创建链表的过程如下:(1)定义一个链表的节点结构,包含数据和指向下一个节点的指针;(2)创建头节点,并将头节点的指针指向NULL,表示链表为空。

2. 插入节点链表的插入操作可以在链表的任意位置插入节点。

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

下面以在链表头部插入节点为例,介绍插入节点的过程:(1)创建一个新节点,设置新节点的数据;(2)将新节点的指针指向原头节点;(3)将头节点的指针指向新节点,完成插入操作。

3. 删除节点链表的删除操作可以删除链表中的任意节点。

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

以下是删除链表头部节点的步骤:(1)将头节点的指针指向下一个节点,跳过原头节点;(2)释放原头节点的内存空间。

4. 遍历链表链表的遍历操作用于访问链表中的每个节点。

通过遍历链表,我们可以获取链表中的所有数据或执行特定的操作。

链表的遍历操作如下:(1)从链表的头节点开始,依次访问每个节点;(2)对每个节点执行相应的操作,如打印节点的数据。

实验结果:通过以上实验过程,我们成功地创建了一个链表,并实现了链表的插入、删除和遍历操作。

链表的基本操作能够灵活地处理数据,适用于各种场景。

链表的插入和删除操作可以在O(1)时间内完成,相较于数组的插入和删除操作具有更高的效率。

实验总结:链表作为一种常见的数据结构,具有灵活性和高效性的特点。

链表基本操作实验报告

链表基本操作实验报告

链表基本操作实验报告#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -1typedef int ElemType ;typedef int Status ;typedef struct LNode {ElemType data ;struct LNode *next ;} *Link,*Position ;typedef struct {Link head,tail;int len;} LinkList;Status InitList ( LinkList &L ){L.head=L.tail=new LNode;L.head->next=L.tail->next=NULL;if(!L.head||!L.tail)return OVERFLOW;L.len=0;return OK;}Status MakeNode(Link &p,ElemType e) { p=new LNode;if(!p)return ERROR;p->data=e;return OK;}void FreeNode(Link &p){delete p;p=NULL;}Status ClearList(LinkList &L) { Link p,q;if(L.head!=L.tail){p=q=L.head->next;L.head->next=NULL;while(p!=L.tail){p=q->next;delete q;q=p;}delete q;L.tail=L.head;L.len=0;}return OK;}Status DestroyList(LinkList &L) { ClearList(L);FreeNode(L.head);L.tail=NULL;L.len=0;return OK;}Status ListEmpty(LinkList L) {if(L.head==NULL)return OVERFLOW; if(L.len)return FALSE;elsereturn TRUE;}int ListLength(LinkList L){return L.len;}Position GetHead(LinkList L){return L.head;}Position GetLast(LinkList L){return L.tail;}Status InsFirst(LinkList &L,Link h,Link s) { h->next=s;s->next=h->next;if(h==L.tail)L.tail=h->next;L.len+=1;return OK;}Status DelFirst(LinkList &L,Link h,Link &q) { q=h->next;h->next=q->next;if(!q)L.tail=h;L.len-=1;return OK;}Status Append(LinkList &L,Link s){Link h;h=L.head;while(h->next!=L.tail)h=h->next;while(s->next!=NULL){h=s;s=s->next;h=h->next;L.len+=1;}s->next=L.tail;L.tail=NULL;return OK;}Status Remove(LinkList &L,Link &q) {Link h;if(ListEmpty(L)==0){q=NULL;return FALSE;}q=L.head;while(q->next!=L.tail)q=q->next;h=q;q=q->next;L.len-=1;return OK;}Position PriorPos(LinkList L,Link p) {Link q=L.head;if(p==q)return NULL;while(q->next!=L.tail){if(q->next==p)return q;q=q->next;}return q;}Status InsBefore(LinkList &L,Link &p,Link s) {Link q;q=PriorPos( L, p);if(!q)q=L.head;q->next=s;s->next=p;p=s;L.len+=1;return OK;}Status LocatePos(LinkList L,int i,Link &p){int j;if(i<=0||i>L.len)return ERROR;else{p=L.head;for(j=1;j<=i;j++)p=p->next;return OK;}}Status compare(ElemType c1,ElemType c2){if(c1==c2)return TRUE;elsereturn FALSE;}Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType c1,ElemType c2)) //important{Link p=L.head;while(p!=L.tail){p=p->next;if(compare(e,p->data) )return p;}return FALSE;}int main(){LinkList L;Link p,h,q;int n,j;ElemType e,f;InitList (L);cout<<"请输入项数"<<endl;< bdsfid="292" p=""></endl;<> cin>>n;cout<<"请输入数据"<<endl;< bdsfid="295" p=""></endl;<> for(int i=0;i<n;i++)< bdsfid="297" p=""></n;i++)<>{cin>>e;MakeNode(p, e);InsFirst(L,L.tail,p);}cout<<"输入后的线性表的长度:"<<listlength(l)<<endl;< bdsfid="304" p=""></listlength(l)<<endl;<>DelFirst(L, L.head,q);cout<<"删除数据为:"<<endl;< bdsfid="307" p=""></endl;<> cout<data<<endl;< bdsfid="310" p=""></endl;<>cout<<"删除后的线性表的长度:"<<listlength(l)<<endl;<bdsfid="312" p=""></listlength(l)<<endl;<>cout<<"请输入要查找数据位序"<<endl;< bdsfid="314" p=""></endl;<>cin>>j;LocatePos( L,j,p);cout<data<<endl;< bdsfid="319" p=""></endl;<>cout<<"请输入要查找数据"<<endl;< bdsfid="321" p=""></endl;<>cin>>f;h=LocateElem(L,f,compare); //重要cout<data<<endl;< bdsfid="326" p=""></endl;<>ClearList(L);return 0;}。

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

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

链表的基本操作数据结构实验报告记录————————————————————————————————作者:————————————————————————————————日期:大学数据结构实验报告课程名称数据结构实验第(四)次实验实验名称链表的基本操作学生姓名于歌专业班级学号实验成绩指导老师(签名)日期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、掌握建立单链表和显示单链表元素的算法。

3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。

2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。

3、删除上述单链表中指定位置的元素。

以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的:本实验的目的是通过实现单链表数据结构,加深对数据结构的理解,并掌握单链表的基本操作和算法。

实验内容: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、单链表的定义和基本操作的源代码文件。

链表-实验报告

链表-实验报告

实验2 链表实验概述:一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现,包括创建、插入、删除、查找、以及合并等操作。

二、实验要求掌握链表存储方式,熟悉链式存储结构。

三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。

步骤:输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5实验结果如图:四、实验环境(使用的软件和设备)(1)实习器材:多媒体计算机。

(2)实习地点:校内多媒体机房。

(3)实习软件: Win-TC实验内容:【实验过程】(实验步骤、记录、数据、分析)实验过程(提示)输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5【结果实验记录】(图形或图像)1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。

链表的基本操作实验报告

链表的基本操作实验报告

《数据结构》实验报告学号1445203105 姓名王胜博班级软件5班成绩实验名称实验三链表的基本操作是否原创是一、实验要求编程实现链表下教材第二章定义的线性表的基本操作,最好用菜单形式对应各个操作,使其编程一个完整的小软件。

二、实验目的通过该实验,深入理解链表的逻辑结构、物理结构等概念,掌握链表基本操作的编程实现,熟练掌握C语言中指针的操作。

和实验2对比,掌握线性结构两种不同存储方式的区别。

三、设计思想用函数执行各个功能,随机插入元素四、主要源代码#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node, *LinkList;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));if(!(*L))printf("存储分配失败\n");(*L)->next=NULL;}void DestroyList(LinkList L){LinkList p;while(L){p=L->next;free(L);L=p;}}int ListLength(LinkList L){LinkList p;int i=0;p=L->next;while(p){i++;p=p->next;}return i;}int GetElem(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}e=p->data;return e;}int GetElemLo(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p->data!=i&&j<=ListLength(L)){p=p->next;++j;}e=j;return e;}void FindPre(LinkList L,int x){LinkList p;p=L;if(p->next->data==x){printf("第一个元素没有前驱\n");}else{while(p->next){if(p->next->data==x){printf("%d的前驱结点是:%d\n",x,p->data);break;}else{p=p->next;}}}}void FindNext(LinkList L,int x){LinkList p;p=L->next;while(p){if(p->data==x){printf("%d的后继结点是:%d\n",x,p->next->data);break;}else{p=p->next;}if(p->next==NULL){printf("最后一个元素没有后继\n");break;}}}void LinkInset_L(LinkList &L,int i,ElemType e){ LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("i小于1或者i大于表长加1\n");LinkList s;s=(LinkList)malloc(sizeof (Node));s->data=e;s->next=p->next;p->next=s;}void ListDelete_L(LinkList &L,int i,ElemType &e){ LinkList p,q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!p->next ||j>i-1)printf("删除位置不合理\n");q=p->next;p->next=q->next;e=q->data;free(q);printf("已删除的元素是:%d\n",e);}void visit(ElemType e){printf("%d,",e);}void ListTraverse(LinkList L){LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");}void CreatListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node));r=*L;for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node));p->data=rand()%100+1;r->next=p;r=p;}r->next=NULL;}int main(){LinkList L;int opp;printf("可执行的操作有:\n");printf("1.初始化或重置链表\n");printf("2.随机插入元素\n");printf("3.显示链表中数据元素个数\n");printf("4.输出所输入的链表元素\n");printf("5.所指位序的元素值\n");printf("6.链表已存在元素的位序\n");printf("7.请输入元素,求直接前驱\n");printf("8.请输入元素,求直接后继\n");printf("9.在第i个位置插入元素\n");printf("10.删除第i个元素\n");printf("11.销毁链表\n");printf("12.退出\n");printf("\n");printf("请输入你的选择:\n");do{scanf("%d",&opp);switch(opp){case 1:{InitList(&L);printf("链表已初始化\n");printf("下一步操作:");break;}case 2:{int n;printf("输入插入元素个数:");scanf("%d",&n);CreatListTail(&L,n);printf("下一步操作:");break;}case 3:{printf("链表中元素的个数是:%d\n",ListLength(L));printf("下一步操作:");break;}case 4:{ListTraverse(L);printf("下一步操作:");break;}case 5:{int m,e;printf("输入要取元素的位置:");scanf("%d",&m);if(m>ListLength(L)){printf("输入有误\n");}else{GetElem(L,m,e);printf("该元素是:%d\n",e);}printf("下一步操作:");break;}case 6:{int i,e;printf("输入要取的元素:");scanf("%d",&i);GetElemLo(L,i,e);printf("该元素的位置是:%d\n",e);printf("下一步操作:");break;}case 7:{int x;printf("要求哪个元素的前驱?");scanf("%d",&x);FindPre(L,x);printf("下一步操作:");break;}case 8:{int x;printf("要求哪个元素的后继?");scanf("%d",&x);FindNext(L,x);printf("下一步操作:");break;}case 9:{int i,e;printf("在哪个位置插入元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{printf("插入的新元素是:");scanf("%d",&e);LinkInset_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 10:{int i,e;printf("要删除哪个位置的元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{ListDelete_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 11:{DestroyList(L);printf("链表已销毁!\n");printf("下一步操作:");break;}case 12:{printf("谢谢使用\n");break;}default:{printf("输入错误,请重新输入\n");break;}}}while(opp!=12);return 0;}五、调试与测试数据六、实验总结。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

链表的基本操作数据结构实验报告记录————————————————————————————————作者:————————————————————————————————日期:大学数据结构实验报告课程名称数据结构实验第(四)次实验实验名称链表的基本操作学生姓名于歌专业班级学号实验成绩指导老师(签名)日期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;}。

相关文档
最新文档