数据结构实验报告
数据结构实验报告实验5
数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构，如链表、栈、队列、树和图等，并通过实际编程实现，提高对数据结构的操作和应用能力。
同时，培养解决实际问题的思维和编程能力，提高代码的可读性、可维护性和效率。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容1、链表的基本操作创建链表插入节点删除节点遍历链表2、栈的实现与应用用数组实现栈用链表实现栈栈的应用：括号匹配3、队列的实现与应用用数组实现队列用链表实现队列队列的应用：排队模拟4、二叉树的遍历前序遍历中序遍历后序遍历5、图的表示与遍历邻接矩阵表示法邻接表表示法深度优先遍历广度优先遍历四、实验步骤1、链表的基本操作创建链表：首先定义一个链表节点结构体，包含数据域和指向下一个节点的指针域。
然后通过动态内存分配创建链表节点，并将节点逐个连接起来，形成链表。
插入节点：根据插入位置的不同，分为在表头插入、在表尾插入和在指定位置插入。
在指定位置插入时，需要先找到插入位置的前一个节点，然后进行节点的连接操作。
删除节点：同样需要根据删除位置的不同进行处理。
删除表头节点时，直接将头指针指向下一个节点；删除表尾节点时，找到倒数第二个节点，将其指针置为空；删除指定位置节点时，找到要删除节点的前一个节点，然后调整指针。
遍历链表：通过从链表头开始，依次访问每个节点，输出节点的数据。
2、栈的实现与应用用数组实现栈：定义一个固定大小的数组作为栈的存储空间，同时用一个变量记录栈顶位置。
入栈操作时，先判断栈是否已满，如果未满则将元素放入栈顶位置，并更新栈顶位置；出栈操作时，先判断栈是否为空，如果不空则取出栈顶元素，并更新栈顶位置。
用链表实现栈：与链表的操作类似，将新元素添加在链表头部作为栈顶。
括号匹配：输入一个包含括号的字符串，使用栈来判断括号是否匹配。
遇到左括号入栈，遇到右括号时与栈顶的左括号进行匹配，如果匹配成功则出栈，否则括号不匹配。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构，由结点和边组成。
树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中，我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树，每个结点最多只有两个子结点。
根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。
然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。
如果当前结点为空，则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。
如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。
- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。
- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。
数据结构实验报告2
数据结构实验报告2数据结构实验报告21、实验目的本次实验的目的是通过使用数据结构来解决一个特定的问题。
具体而言，我们将会使用某种数据结构（例如链表、堆栈、队列等）来实现一个特定功能，并对其性能进行评估。
2、实验背景在本次实验中，我们将会探索数据结构在解决实际问题中的应用。
数据结构是计算机科学的重要组成部分，它提供了一种组织和管理数据的方式，以便能够高效地访问和操作这些数据。
3、实验内容在本次实验中，我们选择了一种经典的数据结构，以实现一个特定的功能。
具体而言，我们将会使用链表来实现一个简单的联系人管理系统。
3.1 数据结构选择我们选择了链表作为联系人管理系统的数据结构。
链表是一种灵活的数据结构，它能够动态地增加或删除元素，并且支持高效的插入和删除操作。
3.2 实现功能我们的联系人管理系统将会具有以下功能：- 添加联系人：用户可以输入联系人的姓名、方式号码等信息，并将其添加到联系人列表中。
- 删除联系人：用户可以选择要删除的联系人，并从列表中删除该联系人。
- 查找联系人：用户可以根据姓名或方式号码来查找联系人，并显示相关信息。
- 显示所有联系人：系统将会将所有联系人按照姓名的字母顺序进行排序，并将其显示在屏幕上。
4、实验步骤下面是本次实验的具体步骤：4.1 初始化联系人管理系统在系统开始之前，我们需要初始化联系人管理系统。
这包括创建一个空的联系人列表，并提供用户菜单来选择相应功能。
4.2 添加联系人用户可以选择添加联系人的功能，并输入联系人的相关信息。
系统将会将联系人添加到联系人列表中。
4.3 删除联系人用户可以选择删除联系人的功能，并输入要删除联系人的姓名或方式号码。
系统将会在联系人列表中查找并删除相应联系人。
4.4 查找联系人用户可以选择查找联系人的功能，并输入要查找联系人的姓名或方式号码。
系统将会在联系人列表中查找相应联系人，并显示其相关信息。
4.5 显示所有联系人用户可以选择显示所有联系人的功能。
数据结构实验报告2篇
数据结构实验报告数据结构实验报告精选2篇（一）实验目的：1. 熟悉数据结构的基本概念和基本操作；2. 掌握线性表、栈、队列、链表等经典数据结构的实现方法；3. 掌握数据结构在实际问题中的应用。
实验内容：本次实验主要包括以下几个部分：1. 线性表的实现方法，包括顺序表和链表，分别使用数组和链表来实现线性表的基本操作；2. 栈的实现方法，包括顺序栈和链式栈，分别使用数组和链表来实现栈的基本操作；3. 队列的实现方法，包括顺序队列和链式队列，分别使用数组和链表来实现队列的基本操作；4. 链表的实现方法，包括单链表、双链表和循环链表，分别使用指针链、双向链和循环链来实现链表的基本操作；5. 综合应用，使用各种数据结构来解决实际问题，例如使用栈来实现括号匹配、使用队列来实现马铃薯游戏等。
实验步骤及结果：1. 线性表的实现方法：a) 顺序表的基本操作：创建表、插入元素、删除元素、查找元素等；b) 链表的基本操作：插入节点、删除节点、查找节点等；c) 比较顺序表和链表的优缺点，分析适用场景。
结果：通过实验，确认了顺序表适用于频繁查找元素的情况，而链表适用于频繁插入和删除节点的情况。
2. 栈的实现方法：a) 顺序栈的基本操作：进栈、出栈、判空、判满等；b) 链式栈的基本操作：进栈、出栈、判空、判满等。
结果：通过实验，掌握了栈的基本操作，并了解了栈的特性和应用场景，例如括号匹配。
3. 队列的实现方法：a) 顺序队列的基本操作：入队、出队、判空、判满等；b) 链式队列的基本操作：入队、出队、判空、判满等。
结果：通过实验，掌握了队列的基本操作，并了解了队列的特性和应用场景，例如马铃薯游戏。
4. 链表的实现方法：a) 单链表的基本操作：插入节点、删除节点、查找节点等；b) 双链表的基本操作：插入节点、删除节点、查找节点等；c) 循环链表的基本操作：插入节点、删除节点、查找节点等。
结果：通过实验，掌握了链表的基本操作，并了解了链表的特性和应用场景。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程，通过本次实验，旨在加深对常见数据结构（如链表、栈、队列、树、图等）的理解和应用，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
操作系统为 Windows 10。
三、实验内容1、链表的实现与操作创建一个单向链表，并实现插入、删除和遍历节点的功能。
对链表进行排序，如冒泡排序或插入排序。
2、栈和队列的应用用栈实现表达式求值，能够处理加、减、乘、除和括号。
利用队列实现银行排队系统的模拟，包括顾客的到达、服务和离开。
3、二叉树的遍历与操作构建一棵二叉树，并实现前序、中序和后序遍历。
进行二叉树的插入、删除节点操作。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历。
四、实验步骤及结果1、链表的实现与操作首先，定义了链表节点的结构体：｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀插入节点的函数：｀｀｀cppvoid insertNode(ListNode& head, int val) ｛ListNode newNode ＝ new ListNode(val)；head ＝ newNode;｝ else ｛ListNode curr ＝ head;while （curr>next!＝ NULL) ｛curr ＝ curr>next;｝curr>next ＝ newNode;｝｝｀｀｀删除节点的函数：｀｀｀cppvoid deleteNode(ListNode& head, int val) ｛if （head ＝＝ NULL) ｛return;｝ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL ＆＆ curr>next>data!＝ val) ｛curr ＝ curr>next;｝if （curr>next!＝ NULL) ｛ListNode temp ＝ curr>next;curr>next ＝ curr>next>next;delete temp;｝｝｀｀｀遍历链表的函数：｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛std:：cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝std:：cout ＜＜ std:：endl;｝｀｀｀对链表进行冒泡排序的函数：｀｀｀cppvoid bubbleSortList(ListNode& head) ｛if （head ＝＝ NULL ｜｜ head>next ＝＝ NULL) ｛return;｝bool swapped;ListNode ptr1;ListNode lptr ＝ NULL;do ｛swapped ＝ false;ptr1 ＝ head;while （ptr1-＞next!＝ lptr) ｛if （ptr1-＞data ＞ ptr1-＞next>data) ｛int temp ＝ ptr1-＞data;ptr1-＞data ＝ ptr1-＞next>data;ptr1-＞next>data ＝ temp;swapped ＝ true;｝ptr1 ＝ ptr1-＞next;｝lptr ＝ ptr1;｝ while （swapped)；｝｀｀｀测试结果：创建了一个包含 5、3、8、1、4 的链表，经过排序后，输出为 1 3 4 5 8 。
数据结构的实验报告
一、实验目的本次实验旨在让学生掌握数据结构的基本概念、逻辑结构、存储结构以及各种基本操作，并通过实际编程操作，加深对数据结构理论知识的理解，提高编程能力和算法设计能力。
二、实验内容1. 线性表（1）顺序表1）初始化顺序表2）向顺序表插入元素3）从顺序表删除元素4）查找顺序表中的元素5）顺序表的逆序操作（2）链表1）创建链表2）在链表中插入元素3）在链表中删除元素4）查找链表中的元素5）链表的逆序操作2. 栈与队列（1）栈1）栈的初始化2）入栈操作3）出栈操作4）获取栈顶元素5）判断栈是否为空（2）队列1）队列的初始化2）入队操作3）出队操作4）获取队首元素5）判断队列是否为空3. 树与图（1）二叉树1）创建二叉树2）遍历二叉树（前序、中序、后序）3）求二叉树的深度4）求二叉树的宽度5）二叉树的镜像（2）图1）创建图2）图的深度优先遍历3）图的广度优先遍历4）最小生成树5）最短路径三、实验过程1. 线性表（1）顺序表1）初始化顺序表：创建一个长度为10的顺序表，初始化为空。
2）向顺序表插入元素：在顺序表的第i个位置插入元素x。
3）从顺序表删除元素：从顺序表中删除第i个位置的元素。
4）查找顺序表中的元素：在顺序表中查找元素x。
5）顺序表的逆序操作：将顺序表中的元素逆序排列。
（2）链表1）创建链表：创建一个带头结点的循环链表。
2）在链表中插入元素：在链表的第i个位置插入元素x。
3）在链表中删除元素：从链表中删除第i个位置的元素。
4）查找链表中的元素：在链表中查找元素x。
5）链表的逆序操作：将链表中的元素逆序排列。
2. 栈与队列（1）栈1）栈的初始化：创建一个栈，初始化为空。
2）入栈操作：将元素x压入栈中。
3）出栈操作：从栈中弹出元素。
4）获取栈顶元素：获取栈顶元素。
5）判断栈是否为空：判断栈是否为空。
（2）队列1）队列的初始化：创建一个队列，初始化为空。
2）入队操作：将元素x入队。
3）出队操作：从队列中出队元素。
数据结构查找实验报告
数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法，包括顺序查找、二分查找、哈希查找等，并通过实际编程实现和性能比较，分析它们在不同数据规模和分布情况下的效率和适用场景。
二、实验环境本次实验使用的编程语言为 Python 38，开发环境为 PyCharm。
实验中所使用的数据集生成工具为 numpy 库。
三、实验原理1、顺序查找顺序查找是一种最简单的查找算法，它从数据结构的开头依次逐个比较元素，直到找到目标元素或遍历完整个数据结构。
其平均时间复杂度为 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中，利用哈希函数计算元素的存储位置，从而实现快速查找。
理想情况下，其平均时间复杂度为 O(1)，但在存在哈希冲突时，性能可能会下降。
四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集，包括有序数据集、无序数据集和具有一定重复元素的数据集。
2、顺序查找实现编写顺序查找算法的函数，接受数据集和目标元素作为参数，返回查找结果（是否找到及查找次数）。
3、二分查找实现实现二分查找算法的函数，同样接受数据集和目标元素作为参数，并返回查找结果。
4、哈希查找实现构建哈希表并实现哈希查找函数，处理哈希冲突的情况。
5、性能比较对不同规模和类型的数据集，分别使用三种查找算法进行查找操作，并记录每种算法的查找时间和查找次数。
五、实验结果与分析1、顺序查找在无序数据集中，顺序查找的性能表现较为稳定，查找时间随着数据规模的增大线性增长。
但在有序数据集中，其性能没有优势。
2、二分查找二分查找在有序数据集中表现出色，查找时间随着数据规模的增大增长缓慢，体现了对数级别的时间复杂度优势。
然而，在无序数据集中无法使用。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统：Windows 102.2 编程语言：C++2.3 开发工具：Visual Studio3. 实验内容3.1 实验一：线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二：栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三：树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法（前序、中序、后序遍历）3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一：实验源代码附件二：实验数据7. 法律名词及注释7.1 版权：著作权法规定的对原创作品享有的权利7.2 专利：国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标：作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议：指允许他人在一定条件下使用自己的知识产权的协议。
国开数据结构(本)数据结构课程实验报告
国开数据结构(本)数据结构课程实验报告1. 实验目的本次实验的主要目的是通过实际操作，掌握数据结构的基本概念、操作和应用。
通过对实验内容的了解和实际操作，达到对数据结构相关知识的深入理解和掌握。
2. 实验工具与环境本次实验主要使用C++语言进行编程，需要搭建相应的开发环境。
实验所需的工具和环境包括：C++编译器、集成开发环境(IDE)等。
3. 实验内容本次实验主要包括以下内容：3.1. 实现顺序存储结构的线性表3.2. 实现链式存储结构的线性表3.3. 实现栈和队列的顺序存储结构和链式存储结构3.4. 实现二叉树的顺序存储结构和链式存储结构3.5. 实现图的邻接矩阵和邻接表表示4. 实验步骤实验进行的具体步骤如下：4.1. 实现顺序存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.2. 实现链式存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.3. 实现栈和队列的顺序存储结构和链式存储结构- 定义数据结构- 实现入栈、出栈、入队、出队操作4.4. 实现二叉树的顺序存储结构和链式存储结构- 定义数据结构- 实现插入、删除、查找等操作4.5. 实现图的邻接矩阵和邻接表表示- 定义数据结构- 实现插入、删除、查找等操作5. 实验结果与分析通过对以上实验内容的实现和操作，得到了以下实验结果与分析： 5.1. 顺序存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.2. 链式存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.3. 栈和队列的顺序存储结构和链式存储结构- 实现了栈和队列的入栈、出栈、入队、出队操作- 通过实验数据进行性能分析，得出了相应的性能指标5.4. 二叉树的顺序存储结构和链式存储结构- 实现了二叉树的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.5. 图的邻接矩阵和邻接表表示- 实现了图的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标6. 总结与展望通过本次数据结构课程的实验，我们深入了解并掌握了数据结构的基本概念、操作和应用。
数据结构课程实验报告
数据结构课程实验报告目录1. 实验简介1.1 实验背景1.2 实验目的1.3 实验内容2. 实验方法2.1 数据结构选择2.2 算法设计2.3 程序实现3. 实验结果分析3.1 数据结构性能分析3.2 算法效率比较3.3 实验结论4. 实验总结1. 实验简介1.1 实验背景本实验是数据结构课程的一次实践性操作，旨在帮助学生加深对数据结构的理解和运用。
1.2 实验目的通过本实验，学生将学会如何选择合适的数据结构来解决特定问题，了解数据结构与算法设计的关系并能将其应用到实际问题中。
1.3 实验内容本实验将涉及对一些经典数据结构的使用，如链表、栈、队列等，并结合具体问题进行算法设计和实现。
2. 实验方法2.1 数据结构选择在实验过程中，需要根据具体问题选择合适的数据结构，比如针对需要频繁插入删除操作的情况可选择链表。
2.2 算法设计针对每个问题，需要设计相应的算法来实现功能，要考虑算法的效率和实际应用情况。
2.3 程序实现根据算法设计，编写相应的程序来实现功能，并进行调试测试确保程序能够正确运行。
3. 实验结果分析3.1 数据结构性能分析在实验过程中，可以通过对不同数据结构的使用进行性能分析，如时间复杂度和空间复杂度等，以便选择最优的数据结构。
3.2 算法效率比较实验完成后，可以对不同算法在同一数据结构下的效率进行比较分析，找出最优算法。
3.3 实验结论根据实验结果分析，得出结论并总结经验教训，为后续的数据结构和算法设计提供参考。
4. 实验总结通过本次实验，学生将对数据结构与算法设计有更深入的了解，并能将所学知识应用到实际问题中，提高自己的实践能力和解决问题的能力。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。
（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。
（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。
数据结构实验报告实验1
数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现，深入理解和掌握常见的数据结构，如线性表、栈、队列等，并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019，编程语言为C+＋。
三、实验内容与步骤（一）线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体，包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
（二）栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
（三）队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析（一）线性表1、顺序表插入操作：在指定位置插入元素时，需要移动后续元素，时间复杂度为 O(n)。
删除操作：删除指定位置的元素时，同样需要移动后续元素，时间复杂度为 O(n)。
查找操作：可以直接通过索引访问元素，时间复杂度为 O(1)。
2、链表插入操作：只需修改指针，时间复杂度为 O(1)。
删除操作：同样只需修改指针，时间复杂度为 O(1)。
查找操作：需要遍历链表，时间复杂度为 O(n)。
（二）栈1、表达式求值能够正确计算简单的四则运算表达式，如 2 ＋ 3 4。
对于复杂表达式，如（2 ＋ 3) 4，也能得到正确结果。
（三）队列1、银行排队系统模拟了客户的到达、排队和服务过程，能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法（一）线性表1、顺序表的空间浪费问题问题描述：当预先分配的空间过大而实际使用较少时，会造成空间浪费。
解决方法：可以采用动态分配空间的方式，根据实际插入的元素数量来调整存储空间。
2、链表的指针操作错误问题描述：在链表的插入和删除操作中，容易出现指针指向错误，导致程序崩溃。
数据结构实验报告
数据结构实验报告数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是CN人才公文网小编给大家整理收集的数据结构实验报告，供大家阅读参考。
数据结构实验报告1一、实验目的及要求1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。
本实验训练的要点是“栈”和“队列”的观点;二、实验内容1) 利用栈，实现数制转换。
2) 利用栈，实现任一个表达式中的语法检查(选做)。
3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);三、实验流程、操作步骤或核心代码、算法片段顺序栈：Status InitStack(SqStack &S){S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status DestoryStack(SqStack &S){free(S.base);return OK;}Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status StackEmpty(SqStack S){if(S.base==S.top)return OK;return ERROR;}int StackLength(SqStack S){return S.top-S.base;}Status GetTop(SqStack S,ElemType &e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Push(SqStack &S,ElemType e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S){ElemType *p;p=(ElemType *)malloc(sizeof(ElemType));if(!p) return ERROR;p=S.top;while(p!=S.base)//S.top上面一个... {p--;printf("%d ",*p);}return OK;}Status Compare(SqStack &S){int flag,TURE=OK,FALSE=ERROR; ElemType e,x;InitStack(S);flag=OK;printf("请输入要进栈或出栈的元素："); while((x= getchar())!='#'&&flag) {switch (x){case '(':case '[':case '{':if(Push(S,x)==OK)printf("括号匹配成功!\n\n"); break;case ')':if(Pop(S,e)==ERROR || e!='('){printf("没有满足条件\n");flag=FALSE;}break;case ']':if ( Pop(S,e)==ERROR || e!='[')flag=FALSE;break;case '}':if ( Pop(S,e)==ERROR || e!='{')flag=FALSE;break;}}if (flag && x=='#' && StackEmpty(S)) return OK;elsereturn ERROR;}链队列：Status InitQueue(LinkQueue &Q) {Q.front =Q.rear=(QueuePtr)malloc(sizeof(QNode));if (!Q.front) return ERROR;Q.front->next = NULL;return OK;}Status DestoryQueue(LinkQueue &Q) {while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue &Q){if(Q.front->next==NULL)return OK;return ERROR;}Status QueueLength(LinkQueue Q){int i=0;QueuePtr p,q;p=Q.front;while(p->next){i++;p=Q.front;q=p->next;p=q;}return i;}Status GetHead(LinkQueue Q,ElemType &e) {QueuePtr p;p=Q.front->next;if(!p)return ERROR;e=p->data;return e;}Status ClearQueue(LinkQueue &Q){QueuePtr p;while(Q.front->next ){p=Q.front->next;free(Q.front);Q.front=p;}Q.front->next=NULL;Q.rear->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e) {QueuePtr p;p=(QueuePtr)malloc(sizeof (QNode));if(!p)return ERROR;p->data=e;p->next=NULL;Q.rear->next = p;Q.rear=p; //p->next 为空return OK;}Status DeQueue(LinkQueue &Q,ElemType &e)。
国开数据结构(本)数据结构课程实验报告(一)
国开数据结构(本)数据结构课程实验报告一、实验目的本实验旨在帮助学生掌握数据结构的基本概念，熟练掌握数据结构的基本操作，进一步提高学生的编程能力和数据处理能力。
二、实验内容1. 数据结构的基本概念在实验中，我们首先介绍了数据结构的基本概念，包括数据的逻辑结构和物理结构，以及数据结构的分类和应用场景。
2. 数据结构的基本操作接着，我们介绍了数据结构的基本操作，包括插入、删除、查找等操作，通过具体的案例和代码演示，让学生理解和掌握这些基本操作的实现原理和方法。
3. 编程实践在实验的第三部分，我们组织学生进行数据结构的编程实践，要求学生通过实际编写代码来实现各种数据结构的基本操作，加深对数据结构的理解和掌握。
三、实验过程1. 数据结构的基本概念在本部分，我们通过课堂讲解和案例分析的方式，向学生介绍了数据结构的基本概念，包括线性结构、树形结构、图形结构等，让学生对数据结构有一个整体的认识。
2. 数据结构的基本操作在这一部分，我们通过具体的案例和代码演示，向学生介绍了数据结构的基本操作，包括插入、删除、查找等操作的实现原理和方法，让学生掌握这些基本操作的具体实现。
3. 编程实践最后，我们组织学生进行数据结构的编程实践，要求他们通过实际编写代码来实现各种数据结构的基本操作，加深对数据结构的理解和掌握，同时也提高了他们的编程能力和数据处理能力。
四、实验结果与分析通过本次实验，学生们对数据结构有了更深入的理解和掌握，他们能够熟练地使用各种数据结构的基本操作，编写出高效、稳定的代码，提高了他们的编程能力和数据处理能力。
五、实验总结本实验对于学生掌握数据结构的基本概念和操作起到了很好的辅助作用，通过实际的编程实践，学生们不仅加深了对数据结构的理解和掌握，同时也提高了他们的编程能力和数据处理能力。
这对于他们今后的学习和工作都具有重要的意义。
六、参考文献1. 《数据结构与算法分析》2. 《数据结构(C语言版)》3. 《数据结构与算法》以上是我对“国开数据结构(本)数据结构课程实验报告”的详细报告，希望能够满足您的要求。
数据结构实验报告及心得体会
数据结构实验报告及心得体会一、实验背景和目的本次实验的目的是通过设计和实现常见的数据结构，来加深对数据结构的理解，并能够熟练运用。
实验中使用的数据结构有栈、队列和链表，通过这些数据结构的设计和应用，能够更好地掌握数据结构的原理和应用。
二、实验过程1. 栈的设计和实现在本次实验中，我设计了一个基于数组的栈，用于存储数据。
首先，我定义了一个栈类，包含栈的容量、栈顶指针和存储数据的数组。
然后，我实现了入栈、出栈和判断栈空、栈满的操作。
在测试阶段，我编写了一些测试用例，验证栈的功能和正确性。
2. 队列的设计和实现在本次实验中，我设计了一个基于链表的队列。
首先，我定义了一个队列类，包含队列的头指针和尾指针。
然后，我实现了入队、出队和判断队列空、队列满的操作。
在测试阶段，我编写了一些测试用例，验证队列的功能和正确性。
3. 链表的设计和实现在本次实验中，我设计了一个能够存储任意数据类型的单链表。
首先，我定义了一个链表类，包含链表的头指针和尾指针。
然后，我实现了插入、删除和查找节点的操作。
在测试阶段，我编写了一些测试用例，验证链表的功能和正确性。
三、实验结果和分析通过本次实验，我成功设计和实现了栈、队列和链表这三种常见的数据结构。
在测试阶段，我对这些数据结构进行了充分的测试，验证了它们的功能和正确性。
在测试过程中，我发现栈和队列在实际应用中具有很大的作用。
例如，在计算表达式的过程中，可以利用栈来实现中缀表达式转后缀表达式的功能；在操作系统中，可以利用队列来实现进程的调度。
此外，在实验过程中，我还进一步加深了对数据结构的理解。
通过设计和实现数据结构，我学会了如何根据问题的需求选择合适的数据结构，并能够运用数据结构解决实际问题。
在实现过程中，我遇到了一些问题，例如链表的插入和删除操作需要考虑前后指针的变化，但通过不断的实践和思考，最终成功解决了这些问题。
同时，我还注意到数据结构的时间复杂度和空间复杂度对算法的性能有着重要的影响，因此在设计数据结构时需要充分考虑这些因素。
(完整版)数据结构实验报告全集
数据结构实验报告全集实验一线性表基本操作和简单程序1．实验目的（1）掌握使用Visual C++ 6.0上机调试程序的基本方法；（2）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。
2．实验要求（1）认真阅读和掌握和本实验相关的教材内容。
（2）认真阅读和掌握本章相关内容的程序。
（3）上机运行程序。
（4）保存和打印出程序的运行结果，并结合程序进行分析。
（5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果实验代码：1）头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2）创建单链表nodetype *create()//建立单链表，由用户输入各结点data域之值，//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值：";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3）输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4）计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5）寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点，并由p指向该节点{j++;p=p->next;}return p;} }6）单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//（i>=0）之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点，并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7）单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点，并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8）释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5．实验结果建立一个单链表：输入第1结点data域值：1输入第2结点data域值：2输入第3结点data域值：3输入第4结点data域值：4输入第5结点data域值：5输入第6结点data域值：6输入第7结点data域值：7输入第8结点data域值：8输入第9结点data域值：9输入第10结点data域值0：输出一个单链表：1 2 3 4 5 6 7 8 9单链表长度：9输出一个单链表：1 02345678 9输出一个单链表：1 2 3 4 5 6 7 8实验二顺序栈的实现1.实验目的掌握顺序栈的基本操作：初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。
数据结构排序实验报告
数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序，并通过实际编程和实验分析，比较它们在不同规模数据下的性能表现，从而为实际应用中选择合适的排序算法提供依据。
二、实验环境本次实验使用的编程语言为 Python 3x，开发环境为 PyCharm。
实验中使用的操作系统为 Windows 10。
三、实验原理1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。
它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
2、插入排序（Insertion Sort）插入排序是一种简单直观的排序算法。
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个数组有序。
3、选择排序（Selection Sort）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
4、快速排序（Quick Sort）通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
5、归并排序（Merge Sort）归并排序是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
四、实验步骤1、算法实现使用 Python 语言分别实现上述五种排序算法。
为每个算法编写独立的函数，函数输入为待排序的列表，输出为排序后的列表。
2、生成测试数据生成不同规模（例如 100、500、1000、5000、10000 个元素）的随机整数列表作为测试数据。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一约瑟夫问题实验学时：3学时实验类型：设计实验要求：必修一、实验目的熟练掌握线性链表的基础知识；能够使用C++或其他程序设计语言编程实现线性链表；能够使用线性链表构造正确而且时间复杂度低的算法解决实际问题；锻炼程序设计能力。
二、实验内容M个教徒和N个非教徒在深海上遇险，必须将N个人投入海中，其余的人才能幸免于难，于是想了一个办法：所有人围成一圆圈，从第一个人开始依次报数，每数到第K个人就将他扔入大海，如此循环进行直到仅余M个人为止。
设计一个算法，找出这样一个排序：使每次被扔进大海的都是非教徒。
并用程序设计语言实现。
三、实验原理、方法和手段使用循环单链表，将每个人作为一个结点，每个结点的指针域指向下一个人，采用循环链表的遍历对每隔N-1个结点的结点进行标记，直至标记出N个结点为止。
该实验亦可用顺序表实现。
四、实验组织运行要求本实验采用集中授课形式，每个同学独立完成上述实验要求。
五、实验条件每人一台计算机独立完成实验，有如下条件：（1）硬件：联想高性能PC机；（2）软件：VC++ 6.0、VC++.Net。
六、实验步骤（1）编写循环链表构造函数Node *Create( )，使链表中每个结点的数据域值为0，并让最后一个结点的指针域指向第一个结点；（2）编写约瑟夫问题函数Node *Move(Node *H,int n);void Insert(Node *H,int pos,int data);（5）主函数中调用Create，Move和Insert，采用具体数据计算，输出结果。
七、实验程序// stdafx.h : 标准系统包含文件的包含文件，// 或是经常使用但不常更改的// 特定于项目的包含文件//#pragma once#include"targetver.h"#include<stdio.h>#include<tchar.h>#include<iostream>using namespace std;struct Node{int judgement;int number;Node *Next;};Node *Create();Node *Move(Node *H,int n);void Insert(Node *H,int pos,int data);// px.cpp : 定义控制台应用程序的入口点。
//#include"stdafx.h"int _tmain(int argc, _TCHAR* argv[]) {int n1,n2,k,c,j=1;cout<<"请输入n1,n2和k"<<endl;cin>>n1>>n2>>k;c=n1+n2;Node *H=Create();for(int i=2;i<=c;i++){Insert(H,i,i);}Node *p=H;Node *q;for (int i=0;i<n2;i++){q=Move(p,k);q->judgement=1;p=q->Next;}p=H;cout<<"排列标记为"<<endl;;do{cout<<p->judgement<<'\t';p=p->Next;j++;}while(j<=c);system("PAUSE");return 0;}Node *Create(){Node *H;H=new Node[1];H->judgement=0;H->number=1;H->Next=H;return H;}void Insert(Node *H,int pos,int data) {Node *p=Move(H,pos-1);Node *q=new Node[1];p->Next=q;q->Next=H;q->number=data;q->judgement=0;}Node *Move(Node *H,int n){Node *p=H;for(int i=1;i<n;){p=p->Next;if (p->judgement==1){continue;}i++;}return p;}// TODO: 在此处引用程序需要的其他头文件八、实验结果实验二串的模式匹配实验学时：2学时实验类型：设计实验要求：必修一、实验目的通过实验，实现串的模式匹配的程序的设计。
二、实验内容对于输入的串T和S，如果S是T的子串，求出S在T中的位置。
三、实验原理、方法和手段KMP算法的改进：每当一趟匹配过程中出现字符比较不等时，不需指针回溯，而是利用得到的部分匹配的结果，将模式向右滑动尽可能远的一段距离后，继续进行比较。
如主串‘s1s2…sn’，模式串‘p1p2…pm’。
当匹配过程中产生失配(即，si¹pj)时，将模式串向右移动至模式中的第k个字符和主串中的第i个字符对齐。
令next[j]=k。
四、实验组织运行要求本实验采用集中授课形式，每个同学独立完成上述实验要求。
五、实验条件每人一台计算机独立完成实验，如下条件：（1）硬件：微机；（2）软件：VC++6.0、VC++.Net。
六、实验步骤（1）编写GetNext函数，函数头建议为int *GetNext(HString T)；（2）调用Next函数，实现KMP函数函数头为int KMP(HString T,HString S)；（3）采用具体实例串，检验所写KMP函数是否正确。
七、实验程序// stdafx.h : 标准系统包含文件的包含文件，// 或是经常使用但不常更改的// 特定于项目的包含文件//#pragma once#include"targetver.h"#include<stdio.h>#include<tchar.h>#include<iostream>using namespace std;void Judge(char s1[50],char s2[50]);// TODO: 在此处引用程序需要的其他头文件// Ex10.cpp : 定义控制台应用程序的入口点。
//#include"stdafx.h"int _tmain(int argc, _TCHAR* argv[]){char s1[50];char s2[50];cout<<"请输入第一个字符串：" <<endl;cin.getline(s1,50);cout<<"请输入第二个字符串："<<endl;cin.getline(s2,50);cout<<"第一个字符串为："<<s1<<endl;cout<<"第二个字符串为："<<s2<<endl;Judge(s1,s2);system("PAUSE");return 0;}void Judge(char s1[50],char s2[50]){int flag=0;for(int i=0;s1[i]!=NULL;i++){int j;for (j=0;j<50&&s2[j]!=NULL;j++){if (s1[i+j]==s2[j])continue;elsebreak;}if (s2[j]==NULL){cout<<"第二个字符串从第"<<i+1<<"处与第一个字符串相匹配"<<endl;flag=1;}elsecontinue;}if (flag==0){cout<<"第二个字符串在第一个字符串中找不到匹配。
"<<endl;}}八、实验结果实验三稀疏矩阵三元组表的转置实验学时：2学时实验类型：综合实验要求：必修一、实验目的通过实验，实现串的模式匹配的程序的设计。
二、实验内容将以数组形式存储的稀疏矩阵转换为三元组表，并将其转置，输出转置后的结果。
三、实验原理、方法和手段创建一个class QOLList用来构架矩阵结构OLNode,在QOLList中写入void Insert(int y, int x, int Data)方法。
通过使用遍历和Insert方法进行转置功能的实现。
四、实验组织运行要求本实验采用集中授课形式，每个同学独立完成上述实验要求。
五、实验条件每人一台计算机独立完成实验，如下条件：（1）硬件：微机；（2）软件：VC++6.0、VC++.Net。
六、实验步骤（1）编写二维数组到三元组表的转换函数。
（2）编写三元组转置函数；（3）在主函数中调用转换函数和转置函数，输出结果。
七、实验程序// stdafx.h : 标准系统包含文件的包含文件，// 或是经常使用但不常更改的// 特定于项目的包含文件//#pragma once#include"targetver.h"#include<stdio.h>#include<tchar.h>#include<iostream>#include"QOLList.h"using namespace std;// TODO: 在此处引用程序需要的其他头文件#pragma oncestruct OLNode{int x,y;int Data;OLNode *pRight,*pDown;};class QOLList{public:QOLList(void);QOLList(int H,int W);~QOLList(void);int m_H,m_W;OLNode *pXHead,*pYHead;OLNode* GetXTail(int x);OLNode* GetYTail(int y);void Insert(int y, int x, int Data);void Cout(void);void DeleteRow(int y);void RemoveNodeX(int x, int y);void InsertRow(OLNode *p,int y);void InsertNodeX(OLNode * p, int x);};#include"StdAfx.h"#include"QOLList.h"QOLList::QOLList(void){}QOLList::QOLList(int H,int W){m_H=H;m_W=W;pXHead=new OLNode[W];pYHead=new OLNode[H];for(int x=0;x<W;x++){pXHead[x].pDown=NULL;pXHead[x].x=x;}for(int y=0;y<W;y++){pYHead[y].pRight=NULL;pYHead[y].y=y;}}QOLList::~QOLList(void){}OLNode* QOLList::GetXTail(int x){OLNode *pX=&pXHead[x];while(pX->pDown!=NULL)pX=pX->pDown;return pX;}OLNode* QOLList::GetYTail(int y){OLNode *pY=&pYHead[y];while(pY->pRight!=NULL)pY=pY->pRight;return pY;}void QOLList::Insert(int y, int x, int Data) {OLNode *p=new OLNode;p->Data=Data;p->pDown=NULL;p->pRight=NULL;p->x=x;p->y=y;OLNode *pX=GetXTail(x);OLNode *pY=GetYTail(y);pX->pDown=p;pY->pRight=p;}void QOLList::Cout(void){for(int y=0;y<m_H;y++){OLNode *pX=&pYHead[y];while(pX->pRight!=NULL){cout<<pX->pRight->Data<<'\t';pX=pX->pRight;}cout<<endl;}}void QOLList::DeleteRow(int y){OLNode *p=pYHead[y].pRight;for(int x=0;x<m_W;x++)RemoveNodeX(x,y);for(int my=y;my<m_H-1;my++)pYHead[my].pRight=pYHead[my+1].pRight;pYHead[m_H-1].pRight=NULL;for(int my=y;my<m_H;my++){OLNode *pX=&pYHead[y];while(pX->pRight!=NULL){pX=pX->pRight;pX->y--;}}}void QOLList::RemoveNodeX(int x, int y){OLNode *p=&pXHead[x];while(p->pDown!=NULL){if(p->pDown->y!=y)p=p->pDown;else{p->pDown=p->pDown->pDown;break;}}}void QOLList::InsertRow(OLNode *p,int y){for(int x=0;x<m_W;x++)RemoveNodeX(x,y);for(int my=y;my<m_H-1;my++)pYHead[my].pRight=pYHead[my+1].pRight;pYHead[m_H-1].pRight=NULL;for(int my=y;my<m_H;my++){OLNode *pX=&pYHead[y];while(pX->pRight!=NULL){pX=pX->pRight;pX->y--;}}}void QOLList::InsertNodeX(OLNode * p, int x) {OLNode *q=&pXHead[x];while(q->pDown!=NULL){if(p->pDown->y<q->y)q=q->pDown;else{p->pDown=q->pDown;q->pDown=p;break;}}}// Ex9.cpp : 定义控制台应用程序的入口点。