数据结构课程设计实验报告
数据结构课程设计实验报告完整版
数据结构课程设计实验报告完整版【正文】一、实验目的本实验主要目的是通过实践，掌握数据结构的基本概念、常见数据结构的实现方式以及在实际应用中的应用场景和效果。
二、实验背景数据结构是计算机科学与技术领域中的一个重要概念，是研究数据的组织方式、存储方式、访问方式以及操作等方面的方法论。
在计算机科学领域，数据结构是实现算法和解决问题的基础，因此对数据结构的理解和应用具有重要意义。
三、实验内容本次数据结构课程设计实验主要分为以下几个部分：1. 实验环境的准备：包括选择合适的开发平台、安装必要的软件和工具。
2. 实验数据的收集和处理：通过合适的方式收集实验所需的数据，并对数据进行处理和整理。
3. 数据结构的选择和实现：根据实验需求，选择合适的数据结构，并进行相应的数据结构实现。
4. 数据结构的测试和优化：对所实现的数据结构进行测试，包括性能测试和功能测试，并根据测试结果对数据结构进行优化和改进。
5. 实验报告的撰写：根据实验过程和结果，撰写完整的实验报告，包括实验目的、实验背景、实验内容、实验结果和结论等。
四、实验过程1. 实验环境的准备本实验选择了Visual Studio作为开发平台，安装了相应版本的Visual Studio，并根据官方指引进行了相应的配置和设置。
2. 实验数据的收集和处理本实验选取了一份包含学生信息的数据集，包括学生姓名、学号、性别、年龄等信息。
通过编写Python脚本，成功提取了所需信息，并对数据进行了清洗和整理。
3. 数据结构的选择和实现根据实验需求，我们选择了链表作为数据结构的实现方式。
链表是一种常见的动态数据结构，能够高效地插入和删除元素，适用于频繁插入和删除的场景。
在实现链表时，我们定义了一个节点结构，包含数据域和指针域。
通过指针的方式将节点连接起来，形成一个链式结构。
同时，我们还实现了相关的操作函数，包括插入、删除、查找等操作。
4. 数据结构的测试和优化在完成链表的实现后，我们对其进行了性能测试和功能测试。
数据结构实验报告_实验报告_
数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是小编给大家整理收集的数据结构实验报告，供大家阅读参考。
数据结构实验报告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) {QueuePtr p;if (Q.front == Q.rear)return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front; //只有一个元素时(不存在指向尾指针) free (p);return OK;}Status QueueTraverse(LinkQueue Q){QueuePtr p,q;if( QueueEmpty(Q)==OK){printf("这是一个空队列!\n");return ERROR;}p=Q.front->next;while(p){q=p;printf("%d<-\n",q->data);q=p->next;p=q;}return OK;}循环队列：Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OWERFLOW);Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e){if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}int QueueLength(SqQueue Q){return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status DestoryQueue(SqQueue &Q){free(Q.base);return OK;}Status QueueEmpty(SqQueue Q) //判空{if(Q.front ==Q.rear)return OK;return ERROR;}Status QueueTraverse(SqQueue Q){if(Q.front==Q.rear)printf("这是一个空队列!");while(Q.front%MAXQSIZE!=Q.rear){printf("%d<- ",Q.base[Q.front]);Q.front++;}return OK;}数据结构实验报告2一.实验内容：实现哈夫曼编码的生成算法。
数据结构实验报告2
数据结构实验报告2数据结构实验报告21、实验目的本次实验的目的是通过使用数据结构来解决一个特定的问题。
具体而言，我们将会使用某种数据结构（例如链表、堆栈、队列等）来实现一个特定功能，并对其性能进行评估。
2、实验背景在本次实验中，我们将会探索数据结构在解决实际问题中的应用。
数据结构是计算机科学的重要组成部分，它提供了一种组织和管理数据的方式，以便能够高效地访问和操作这些数据。
3、实验内容在本次实验中，我们选择了一种经典的数据结构，以实现一个特定的功能。
具体而言，我们将会使用链表来实现一个简单的联系人管理系统。
3.1 数据结构选择我们选择了链表作为联系人管理系统的数据结构。
链表是一种灵活的数据结构，它能够动态地增加或删除元素，并且支持高效的插入和删除操作。
3.2 实现功能我们的联系人管理系统将会具有以下功能：- 添加联系人：用户可以输入联系人的姓名、方式号码等信息，并将其添加到联系人列表中。
- 删除联系人：用户可以选择要删除的联系人，并从列表中删除该联系人。
- 查找联系人：用户可以根据姓名或方式号码来查找联系人，并显示相关信息。
- 显示所有联系人：系统将会将所有联系人按照姓名的字母顺序进行排序，并将其显示在屏幕上。
4、实验步骤下面是本次实验的具体步骤：4.1 初始化联系人管理系统在系统开始之前，我们需要初始化联系人管理系统。
这包括创建一个空的联系人列表，并提供用户菜单来选择相应功能。
4.2 添加联系人用户可以选择添加联系人的功能，并输入联系人的相关信息。
系统将会将联系人添加到联系人列表中。
4.3 删除联系人用户可以选择删除联系人的功能，并输入要删除联系人的姓名或方式号码。
系统将会在联系人列表中查找并删除相应联系人。
4.4 查找联系人用户可以选择查找联系人的功能，并输入要查找联系人的姓名或方式号码。
系统将会在联系人列表中查找相应联系人，并显示其相关信息。
4.5 显示所有联系人用户可以选择显示所有联系人的功能。
数据结构实验报告一
数据结构实验报告一数据结构实验报告一一、引言数据结构是计算机科学中非常重要的一门课程，它研究的是数据的组织、存储和管理方式。
在本次实验中，我们将学习并实践一些常用的数据结构，包括数组、链表和栈。
通过实验，我们将深入理解这些数据结构的原理和应用。
二、实验目的本次实验的目的是通过编写代码实现一些常用的数据结构，并测试它们的功能和性能。
通过实际操作，我们将掌握这些数据结构的基本操作和使用方法。
三、实验过程1. 数组数组是一种线性数据结构，它由一组连续的存储单元组成。
在本次实验中，我们将实现一个动态数组，它可以根据需要自动调整大小。
我们首先定义一个数组类，包含插入、删除和查找等基本操作。
然后，我们编写测试代码，验证数组的功能和性能。
2. 链表链表是另一种常用的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中，我们将实现一个单向链表。
我们首先定义一个节点类，然后定义一个链表类，包含插入、删除和查找等基本操作。
最后，我们编写测试代码，验证链表的功能和性能。
3. 栈栈是一种特殊的线性数据结构，它只能在一端进行插入和删除操作。
栈的特点是后进先出（LIFO）。
在本次实验中，我们将实现一个栈。
我们首先定义一个栈类，包含入栈、出栈和查看栈顶元素等基本操作。
然后，我们编写测试代码，验证栈的功能和性能。
四、实验结果通过实验，我们成功实现了动态数组、单向链表和栈的基本操作。
我们编写了测试代码，并对这些数据结构的功能和性能进行了验证。
实验结果表明，这些数据结构在不同场景下都有很好的表现，并且可以满足我们的需求。
五、实验总结本次实验让我们更加深入地理解了数据结构的原理和应用。
通过实际编写代码并进行测试，我们掌握了数组、链表和栈等常用数据结构的基本操作和使用方法。
实验过程中，我们遇到了一些问题，但通过不断的调试和优化，最终成功解决了这些问题。
通过本次实验，我们不仅提高了编程能力，也增强了对数据结构的理解和应用能力。
数据结构实验报告2篇
数据结构实验报告数据结构实验报告精选2篇（一）实验目的：1. 熟悉数据结构的基本概念和基本操作；2. 掌握线性表、栈、队列、链表等经典数据结构的实现方法；3. 掌握数据结构在实际问题中的应用。
实验内容：本次实验主要包括以下几个部分：1. 线性表的实现方法，包括顺序表和链表，分别使用数组和链表来实现线性表的基本操作；2. 栈的实现方法，包括顺序栈和链式栈，分别使用数组和链表来实现栈的基本操作；3. 队列的实现方法，包括顺序队列和链式队列，分别使用数组和链表来实现队列的基本操作；4. 链表的实现方法，包括单链表、双链表和循环链表，分别使用指针链、双向链和循环链来实现链表的基本操作；5. 综合应用，使用各种数据结构来解决实际问题，例如使用栈来实现括号匹配、使用队列来实现马铃薯游戏等。
实验步骤及结果：1. 线性表的实现方法：a) 顺序表的基本操作：创建表、插入元素、删除元素、查找元素等；b) 链表的基本操作：插入节点、删除节点、查找节点等；c) 比较顺序表和链表的优缺点，分析适用场景。
结果：通过实验，确认了顺序表适用于频繁查找元素的情况，而链表适用于频繁插入和删除节点的情况。
2. 栈的实现方法：a) 顺序栈的基本操作：进栈、出栈、判空、判满等；b) 链式栈的基本操作：进栈、出栈、判空、判满等。
结果：通过实验，掌握了栈的基本操作，并了解了栈的特性和应用场景，例如括号匹配。
3. 队列的实现方法：a) 顺序队列的基本操作：入队、出队、判空、判满等；b) 链式队列的基本操作：入队、出队、判空、判满等。
结果：通过实验，掌握了队列的基本操作，并了解了队列的特性和应用场景，例如马铃薯游戏。
4. 链表的实现方法：a) 单链表的基本操作：插入节点、删除节点、查找节点等；b) 双链表的基本操作：插入节点、删除节点、查找节点等；c) 循环链表的基本操作：插入节点、删除节点、查找节点等。
结果：通过实验，掌握了链表的基本操作，并了解了链表的特性和应用场景。
数据结构课程设计实验报告 完整版
第一章链表的应用线性表是数据结构中最简单、最常用的一种线性结构，也是学习数据结构全部内容的基础，其掌握的好坏直接影响着后继课程的学习。
线性表的顺序存储结构，即顺序表的概念相对比较简单，因此，本章的主要任务是使用有关单链表的操作来实现通讯录信息系统的管理。
1.1设计要求本章的设计实验要求使用有关链表的操作来实现通讯录信息系统的管理。
为了验证算法，通讯录管理包括单通讯录链表的建立、通讯者的插入、通讯者的删除、通讯者的查询及通讯录表的输出等。
主控菜单的设计要求使用数字0—5来选择菜单项，其他输入则不起作用。
程序运行后，给出6个菜单项的内容和输入提示：1．通讯录链表的建立2. 通讯者结点的插入3. 通讯者结点的查询4. 通讯者结点的删除5. 通讯录链表的输出0. 退出管理系统请选择0—5：1.2设计分析1.2.1主控菜单函数设计分析1.实现循环和功能选择首先编写一个主控菜单驱动程序，输入0—5以进入相应选择项。
假设输入选择用变量sn存储，它作为menu_select函数的返回值给switch语句。
使用for循环实现重复选择，并在主函数main()中实现。
实际使用时，只有选择大于5或小于0的值，程序才能结束运行，这就要使用循环控制。
这里使用for循环语句实现菜单的循环选择，为了结束程序的运行，使用了“return”语句，也可以使用“exit(0);”语句。
2.得到sn的合理值如前所述，应该设计一个函数用来输出提示信息和处理输入，这个函数应该返回一个数值sn，以便供给switch语句使用。
假设函数名为menu_select,对于sn的输入值，在switch 中case语句对应数字1—5，对于不符合要求的输入，提示输入错误并要求重新输入。
将该函数与主函数合在一起，编译运行程序，即可检查并验证菜单选择是否正确。
1.2.2功能函数设计分析1.建立通讯录链表的设计这里实际上是要求建立一个带头结点的单链表。
建立单链表有两种方法，一种称之为头插法，另一种称为尾插法。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程，通过本次实验，旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括：1、熟练掌握线性表（如顺序表、链表）的基本操作，如插入、删除、查找等。
2、理解栈和队列的特性，并能够实现其基本操作。
3、掌握树（二叉树、二叉搜索树）的遍历算法和基本操作。
4、学会使用图的数据结构，并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称，编程语言为具体编程语言名称。
三、实验内容及步骤（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构，包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构，包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
（二）栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
（三）树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
（四）图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析（一）线性表1、顺序表插入操作在表尾进行时效率较高，在表头或中间位置插入时需要移动大量元素，时间复杂度较高。
删除操作同理，在表尾删除效率高，在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针，时间复杂度较低，但查找操作需要遍历链表，效率相对较低。
（二）栈和队列1、栈栈的特点是先进后出，适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出，常用于排队、任务调度等场景。
数据结构课程设计报告 (4)
数据结构课程设计报告1、引言数据结构是计算机科学中的重要基础课程，它研究如何组织和管理数据以及数据之间的关系。
掌握良好的数据结构对于程序设计和算法的实现至关重要。
本报告将介绍在数据结构课程中完成的设计项目，主要包括设计目标、设计思路、实现细节以及结果分析等内容。
2、设计目标本设计项目的目标是实现一个简单的学生成绩管理系统，该系统能够实现对学生的基本信息以及各门课程成绩的管理和查询。
设计的关键要求如下：1.能够添加学生信息并关联其各门课程成绩；2.能够根据学号查询学生信息以及其各门课程成绩；3.能够计算学生的总成绩和平均成绩；4.能够实现对学生信息和成绩的修改和删除操作。
3、设计思路为了实现上述设计目标，我们采用了链表数据结构来保存学生信息和成绩。
链表的节点用来存储学生的基本信息，如学号、姓名、性别等，同时还包含一个指向课程成绩链表的指针。
课程成绩链表的节点用来存储每门课程的成绩。
在添加学生信息时，我们按照学号的顺序将学生节点插入到链表中。
通过遍历链表，我们可以根据学号查找到对应的学生节点，并进一步查找到该学生的课程成绩链表。
对于查询操作，我们可以通过遍历链表找到匹配的学生节点，然后输出其基本信息和课程成绩。
计算总成绩和平均成绩可以通过遍历课程成绩链表并累加每门课程的成绩来实现。
修改和删除操作可以通过遍历链表找到匹配的学生节点，并进行相应的修改或删除操作。
4、实现细节该学生成绩管理系统的具体实现细节如下：•使用C++编程语言实现；•采用链表数据结构，分别设计了学生信息链表和课程成绩链表；•学生信息链表的节点包括学号、姓名、性别等信息，以及指向课程成绩链表的指针；•课程成绩链表的节点包括课程名称和成绩信息；•提供了添加学生信息、添加课程成绩、查询学生信息、查询课程成绩、计算总成绩和平均成绩等功能；•通过遍历链表实现对学生信息和成绩的修改和删除操作。
5、结果分析经过测试和验证，该学生成绩管理系统能够满足设计目标，并能够正常运行。
数据结构实验六报告
数据结构实验六报告第一篇：数据结构实验六报告实验六报告课程名称：数据结构实验名称：二叉树的应用实验日期2011/11/23一、实验目的：掌握赫夫曼二叉树的建立及赫夫曼编码的生成。
二、实验内容与要求：根据给定的n个权值生成赫夫曼二叉树，输出赫夫曼编码。
三、数据结构设计顺序表的存储结构，建立了二叉树的关系Struct HTNode{int weight;unsigned int parent,lchild,rchild;};四、算法设计1、从数据中选择较小的两个数据元素void Select(HTNode *HT, const int n, int &a, int &b){ //选择较小的两个元素} int x,y;x=y=0x7fff;for(int j=0;jif(HT[j].parent==0)if(HT[j].weight2、建立赫夫曼树void CreatHuff(HTNode *HT,int *p,const int n){} int m=2*n-1;int i,a,b;for(i=0;iSelect(HT ,i,a,b);HT[a].parent=HT[b].parent=i;HT[i].weight=H T[a].weight+HT[b].weight;HT[i].lchild=a;HT[i].rchild=b;}3、生成赫夫曼编码void HuffCoding(HTNode *HT, Huffcode &HC, const int n){ //}HC=newchar*[n+1];char *code=new char[n];code[n-1]='';int i,j,p,k;for(i=0;i} delete[] code;j=n-1;k=i;while(HT[k].parent){p=HT[k].parent;if(HT[p].lchild==k)code[--j]='0';else code[--j]='1';k=p;} HC[i]=(char*)malloc((n-j)*sizeof(char));HC[i]=new char[n-j];strcpy(HC[i],&code[j]);五、测试结果测试数据一：测试数据二：六、心得体会这次实验是在前面的实验基础之上，加上只用了顺序表的存储结构，所以比较简单。
数据结构实验报告5
数据结构实验报告5正文：1. 引言本实验报告旨在介绍数据结构的相关概念和算法，并通过具体案例分析展示其应用。
该报告包含以下章节：背景知识、实验目标、方法与步骤、结果与讨论以及总结。
2. 背景知识在开始进行实验之前，我们需要了解一些基础的数据结构概念，如数组、链表等。
此外还需掌握常见的排序算法（例如冒泡排序和快速排序）以及查找算法（例如二分查找）。
这些基础知识将为后续实验提供必要支持。
3. 实验目标本次实验有两个主要目标：- 理解并独立编写各种数据结构；- 探索不同类型的问题，并使用适当的数据结构来解决它们；4. 方法与步骤4.1 数据集准备阶段：首先，我们需要选择一个合适且真是性质良好地测试样例作为输入。
然后根据所选题型设计相应规模大小或特殊情形下得到期望输出值。
最后对于每组样例都能够正确运行程序代码而产生预期答案即可进入下一环节。
4.2 编码阶段:按照给定任务的要求，使用合适的数据结构和算法编写代码。
确保程序能够正确地处理各种输入情况，并返回预期结果。
4.3 测试与分析阶段:对于每个实验样例，我们需要进行测试以验证其准确性。
通过比较输出结果与预期答案来判断是否成功解决问题。
同时还需考虑时间复杂度、空间复杂度等因素评估所设计算法的效率及优劣程度。
5. 结果与讨论在本节中将展示并讨论实验过程中得到的具体结果。
包括但不限于：- 算法运行时间；- 内存占用情况；- 输出正确性；6. 总结总结报告内容，并回顾整个实验流程和成果。
指出可能存在改进之处或者未来可以深入研究探索领域。
附件：（请参见相关文件）注释：1）数组：一组连续内存单元集合，在计算机科学中广泛应用。
2）链表：由节点组成线性序列，其中每一个节点都连接着下一个节点地址信息。
数据结构实验报告(实验)
深 圳 大 学 实 验 报 告课程名称： 数据结构实验与课程设计 实验项目名称： 实验一：顺序表的应用 学院： 计算机与软件学院 专业： 指导教师： **报告人： 文成 学号： ********** 班级： 5 实验时间： 2012-9-17实验报告提交时间： 2012-9-24教务部制一、实验目的与要求：目的：1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求：1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容：Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行插入操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行删除操作后，顺序表内的所有数据，数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置，对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据，数据是小于100的正整数第三行输入两个参数，表示要交换的两个位置第四行输入两个参数，表示要交换的两个位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行第一次交换操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行第二次交换操作后，顺序表内的所有数据，数据之间用空格隔开注意加入交换位置的合法性检查，如果发现位置不合法，输出error。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)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. 实验简介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. 实验总结通过本次实验，学生将对数据结构与算法设计有更深入的了解，并能将所学知识应用到实际问题中，提高自己的实践能力和解决问题的能力。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程，通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。
本次实验的主要目的包括：1、熟悉常见的数据结构，如链表、栈、队列、树和图等。
2、掌握数据结构的基本操作，如创建、插入、删除、遍历等。
3、提高编程能力和解决实际问题的能力，能够运用合适的数据结构解决具体的问题。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。
双向链表的实现和基本操作。
循环链表的特点和应用。
2、栈和队列的实现栈的后进先出特性，实现入栈和出栈操作。
队列的先进先出原则，完成入队和出队功能。
3、树的操作二叉树的创建、遍历（前序、中序、后序）。
二叉搜索树的插入、查找和删除操作。
4、图的表示与遍历邻接矩阵和邻接表表示图。
深度优先搜索和广度优先搜索算法的实现。
四、实验步骤及结果1、链表的实现与操作单向链表：首先，定义了链表节点的结构体，包含数据域和指向下一个节点的指针域。
通过创建链表头节点，并使用循环依次插入新节点，实现了链表的创建。
插入节点时，根据指定位置找到插入点的前一个节点，然后修改指针完成插入操作。
删除节点时，同样找到要删除节点的前一个节点，修改指针完成删除。
实验结果：成功创建、插入和删除了单向链表的节点，并正确输出了链表的内容。
双向链表：双向链表节点结构体增加了指向前一个节点的指针。
创建、插入和删除操作需要同时维护前后两个方向的指针。
实验结果：双向链表的各项操作均正常，能够双向遍历链表。
循环链表：使链表的尾节点指向头节点，形成循环。
在操作时需要特别注意循环的边界条件。
实验结果：成功实现了循环链表的创建和遍历。
2、栈和队列的实现栈：使用数组或链表来实现栈。
入栈操作将元素添加到栈顶，出栈操作取出栈顶元素。
实验结果：能够正确进行入栈和出栈操作，验证了栈的后进先出特性。
国开数据结构(本)数据结构课程实验报告(一)
国开数据结构(本)数据结构课程实验报告一、实验目的本实验旨在帮助学生掌握数据结构的基本概念，熟练掌握数据结构的基本操作，进一步提高学生的编程能力和数据处理能力。
二、实验内容1. 数据结构的基本概念在实验中，我们首先介绍了数据结构的基本概念，包括数据的逻辑结构和物理结构，以及数据结构的分类和应用场景。
2. 数据结构的基本操作接着，我们介绍了数据结构的基本操作，包括插入、删除、查找等操作，通过具体的案例和代码演示，让学生理解和掌握这些基本操作的实现原理和方法。
3. 编程实践在实验的第三部分，我们组织学生进行数据结构的编程实践，要求学生通过实际编写代码来实现各种数据结构的基本操作，加深对数据结构的理解和掌握。
三、实验过程1. 数据结构的基本概念在本部分，我们通过课堂讲解和案例分析的方式，向学生介绍了数据结构的基本概念，包括线性结构、树形结构、图形结构等，让学生对数据结构有一个整体的认识。
2. 数据结构的基本操作在这一部分，我们通过具体的案例和代码演示，向学生介绍了数据结构的基本操作，包括插入、删除、查找等操作的实现原理和方法，让学生掌握这些基本操作的具体实现。
3. 编程实践最后，我们组织学生进行数据结构的编程实践，要求他们通过实际编写代码来实现各种数据结构的基本操作，加深对数据结构的理解和掌握，同时也提高了他们的编程能力和数据处理能力。
四、实验结果与分析通过本次实验，学生们对数据结构有了更深入的理解和掌握，他们能够熟练地使用各种数据结构的基本操作，编写出高效、稳定的代码，提高了他们的编程能力和数据处理能力。
五、实验总结本实验对于学生掌握数据结构的基本概念和操作起到了很好的辅助作用，通过实际的编程实践，学生们不仅加深了对数据结构的理解和掌握，同时也提高了他们的编程能力和数据处理能力。
这对于他们今后的学习和工作都具有重要的意义。
六、参考文献1. 《数据结构与算法分析》2. 《数据结构(C语言版)》3. 《数据结构与算法》以上是我对“国开数据结构(本)数据结构课程实验报告”的详细报告，希望能够满足您的要求。
数据结构实验报告实验5
数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构，通过实际编程实现和操作，提高对数据结构的应用能力和编程技巧。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验内容1、线性表的基本操作实现线性表的创建、插入、删除、查找等基本操作。
对不同操作的时间复杂度进行分析和比较。
2、栈和队列的应用利用栈实现表达式求值。
使用队列模拟银行排队系统。
3、二叉树的遍历实现二叉树的先序、中序、后序遍历算法。
分析不同遍历算法的特点和应用场景。
4、图的表示和遍历采用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历算法。
四、实验步骤及结果1、线性表的基本操作首先，定义了一个线性表的结构体，包含数据域和指针域。
创建线性表时，动态分配内存空间，并初始化表头和表尾指针。
插入操作分为表头插入、表尾插入和指定位置插入。
在指定位置插入时，需要先找到插入点的前一个节点，然后进行插入操作。
删除操作同样需要找到要删除节点的前一个节点，然后释放删除节点的内存空间，并调整指针。
查找操作通过遍历线性表，逐个比较数据值来实现。
经过测试，不同操作的时间复杂度如下：创建操作的时间复杂度为 O(1)。
插入操作在表头和表尾插入的时间复杂度为 O(1)，在指定位置插入的时间复杂度为 O(n)。
删除操作的时间复杂度为 O(n)。
查找操作的平均时间复杂度为 O(n)。
2、栈和队列的应用表达式求值：将表达式转换为后缀表达式，然后利用栈进行计算。
遇到操作数则入栈，遇到操作符则从栈中弹出两个操作数进行计算，并将结果入栈。
最后栈顶元素即为表达式的结果。
银行排队系统：使用队列模拟客户的排队过程。
客户到达时入队，服务窗口空闲时从队列头部取出客户进行服务。
实验结果表明，栈和队列能够有效地解决相关问题，提高程序的效率和可读性。
3、二叉树的遍历先序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程，通过本次实验，旨在加深对常见数据结构（如数组、链表、栈、队列、树、图等）的理解和运用，提高编程能力和问题解决能力，培养算法设计和分析的思维。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容1、数组与链表的实现与操作分别实现整数数组和整数链表的数据结构。
实现数组和链表的插入、删除、查找操作，并比较它们在不同操作下的时间复杂度。
2、栈与队列的应用用数组实现栈结构，用链表实现队列结构。
模拟栈的入栈、出栈操作和队列的入队、出队操作，解决实际问题，如表达式求值、任务调度等。
3、二叉树的遍历构建二叉树的数据结构。
实现先序遍历、中序遍历和后序遍历三种遍历算法，并输出遍历结果。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先搜索（DFS）和广度优先搜索（BFS）算法，并分析它们的时间复杂度。
四、实验步骤1、数组与链表数组的实现：定义一个固定大小的整数数组，通过索引访问和操作数组元素。
链表的实现：定义链表节点结构体，包含数据和指向下一个节点的指针。
插入操作：对于数组，若插入位置在末尾，直接赋值；若不在末尾，需移动后续元素。
对于链表，找到插入位置的前一个节点，修改指针。
删除操作：数组需移动后续元素，链表修改指针即可。
查找操作：数组通过索引直接访问，链表需逐个节点遍历。
2、栈与队列栈的实现：用数组模拟栈，设置栈顶指针。
队列的实现：用链表模拟队列，设置队头和队尾指针。
入栈和出栈操作：入栈时，若栈未满，将元素放入栈顶，栈顶指针加 1。
出栈时，若栈不为空，取出栈顶元素，栈顶指针减 1。
入队和出队操作：入队时，在队尾添加元素。
出队时，取出队头元素，并更新队头指针。
3、二叉树构建二叉树：采用递归方式创建二叉树节点。
先序遍历：先访问根节点，再递归遍历左子树，最后递归遍历右子树。
中序遍历：先递归遍历左子树，再访问根节点，最后递归遍历右子树。
数据结构实验报告顺序表
数据结构实验报告顺序表数据结构实验报告：顺序表摘要：顺序表是一种基本的数据结构，它通过一组连续的存储单元来存储线性表中的数据元素。
在本次实验中，我们将通过实验来探索顺序表的基本操作和特性，包括插入、删除、查找等操作，以及顺序表的优缺点和应用场景。
一、实验目的1. 理解顺序表的概念和特点；2. 掌握顺序表的基本操作；3. 了解顺序表的优缺点及应用场景。
二、实验内容1. 实现顺序表的初始化操作；2. 实现顺序表的插入操作；3. 实现顺序表的删除操作；4. 实现顺序表的查找操作；5. 对比顺序表和链表的优缺点；6. 分析顺序表的应用场景。
三、实验步骤与结果1. 顺序表的初始化操作在实验中，我们首先定义了顺序表的结构体，并实现了初始化操作，即分配一定大小的存储空间，并将表的长度设为0，表示表中暂时没有元素。
2. 顺序表的插入操作接下来，我们实现了顺序表的插入操作。
通过将插入位置后的元素依次向后移动一位，然后将新元素插入到指定位置，来实现插入操作。
我们测试了在表中插入新元素的情况，并验证了插入操作的正确性。
3. 顺序表的删除操作然后，我们实现了顺序表的删除操作。
通过将删除位置后的元素依次向前移动一位，来实现删除操作。
我们测试了在表中删除元素的情况，并验证了删除操作的正确性。
4. 顺序表的查找操作最后，我们实现了顺序表的查找操作。
通过遍历表中的元素，来查找指定元素的位置。
我们测试了在表中查找元素的情况，并验证了查找操作的正确性。
四、实验总结通过本次实验，我们对顺序表的基本操作有了更深入的了解。
顺序表的插入、删除、查找等操作都是基于数组的操作，因此在插入和删除元素时，需要移动大量的元素，效率较低。
但是顺序表的优点是可以随机访问，查找效率较高。
在实际应用中，顺序表适合于元素数量不变或变化不大的情况，且需要频繁查找元素的场景。
综上所述，顺序表是一种基本的数据结构，我们通过本次实验对其有了更深入的了解，掌握了顺序表的基本操作，并了解了其优缺点及应用场景。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《空间数据结构基础》课程实习报告（测绘10级）姓名班级学号环境与测绘学院1C++面向对象程序设计基础【实验简介】学会用算法语言C++描述抽象数据类型，使用模板建立数据结构。
理解数据结构的组成分为两部分，第一部分是数据集（数据元素），第二部分是在此数据集上的操作。
从面向对象的观点看，这两部分代表了对象的属性和方法。
掌握用C++描述数据结构的基本方法，即通过建立类来描述抽象数据类型。
类的数据成员提供对象属性，成员函数提供操作方法，方法是公共接口，用户通过调用方法实现对属性的访问。
【实验内容】1.定义三维空间的坐标点TPoint2.描述三维空间的球TBall，实现其主要操作（如计算体积和表面积，输出空间坐标等）。
【主要代码】头文件：TPoint.h:#ifndef TPOINT_H#define TPOINT_H#include<iostream>using namespace std;class TPoint{public:TPoint(double xx,double yy,double zz):x(xx),y(yy),z(zz){}TPoint(TPoint &TP):x(TP.x),y(TP.y),z(TP.z){}double getX()const{return x;}//取x坐标值double getY()const{return y;}//取y坐标值double getZ()const{return z;}//取z坐标值void DisplayTP() const {cout<<"("<<x<<","<<y<<","<<z<<")"<<endl;}//显示点的三坐标void Move(double Mx,double My,double Mz);//移动点的坐标private:double x,y,z;//点的三坐标};#endifTBall.h#ifndef TBALL_H#define TBALL_H#include "TPoint.h"const double PI = 3.14159;class TBall{public:TBall(TPoint SC,double R):sphCtr(SC),r(R){}//构造函数TBall(TBall &TB):sphCtr(TB.sphCtr),r(TB.r){}double getSurfArea()const;//计算球的表面积double getV olume()const;//计算球的体积TPoint getSphctr(){return sphCtr;}double getRadius()const{return r;}//取球的半径void Move(double Mx,double My,double Mz){sphCtr.Move(Mx,My,Mz);}//在空间坐标系内移动球void ChangR(double newR){r = newR;}void DisBallInfo()const;//显示球体的基本信息private:TPoint sphCtr;//球心坐标double r;//球的半径};#endif源文件：Define.cpp:#include <iostream>#include "TBall.h"using namespace std;/////////////////TPoint////////////////////////////////void TPoint::Move(double Mx,double My,double Mz)//移动点的坐标{x += Mx;y += My;z += Mz;}/////////////////TBall////////////////////////////////double TBall::getSurfArea()const//计算球的表面积{return 4*PI*r*r;}double TBall::getV olume()const//计算球的体积{return (4.0/3)*PI*r*r*r;}void TBall::DisBallInfo()const//显示球体的基本信息{cout<<"INFORMATION OF THIS BALL: "<<endl;cout<<'\t'<<"SPHERICAL CENTRE: ";sphCtr.DisplayTP();cout<<'\t'<<"RADIUS: "<<r<<endl;cout<<'\t'<<"SURFACE AREA: "<<getSurfArea()<<endl;cout<<'\t'<<"VOLUME: "<<getV olume()<<endl;}Main.cpp:#include<iostream>#include "TBall.h"#include"TPoint.h"using namespace std;void main(){TPoint TP1(1,3,2);TBall TB1(TP1,7);TP1.DisplayTP();TB1.DisBallInfo();TB1.Move(3,2,5);TB1.ChangR(22);TB1.DisBallInfo();}【实验过程】设计好点类和球类的相关属性和操作后，打开C++编译环境，建立两个空的头文件，分别输入点类和球类的声明代码。
然后新建一个源文件，输入点类和球类的函数体实现代码。
最后新建主文件，对两个类的构造函数、复制构造函数、操作函数等进行调试，最后进行评估。
【实验体会】初步了解了面向对象的编程方式，体会到了函数声明与实现分离的安全性。
2链表的建立、合并与拆分【实验简介】链表是用链接存储的方式来表达线性表，它用指针表示结点间的逻辑关系，链表适用于插入或删除频繁，存储空间需求不定的情形。
【实验内容】定义一个链表存储的线性表，除已给出的表元素插入、删除、查找等基本操作外，再提供表的合并、拆分和逆置等操作。
在应用程序中建立两个整型的单链表对象A和B，应用线性表的基本操作对表的实例对象进行操作测试。
1. 设线性链表A=(a1,a2,…,am),，B=(b1,b2,…bm)，按下列规则合并A，B为线性表C 的算法，即使得C = (a1,b1,…,am,bm, b(m+1),…,bn) 当m<=n或 C = (a1,b1,…,an,bn, a(n+1),…,am) 当m>nC表利用A表和B表中的结点空间构成。
2. 将C表原地逆置。
3. 将C表的中偶数和奇数分别链接为两个循环链表D和E。
说明：每一次合并、拆分和逆置等操作的结果均要输出。
【主要代码】单链表头文件：LinkedList.h#ifndef LINKEDLIST_H#define LINKEDLIST_H#include <iostream.h>#include "LinkNode.h"template<class T>class LinkedList{public:LinkedList(){first = new LinkNode<T>;}//默认构造函数LinkedList(const T &x){first = new LinkNode<T>(x);}//带形参的构造函数LinkedList(LinkedList<T> &L);//复制构造函数~LinkedList(){makeEmpty();}//析构函数void makeEmpty();//将表置空int Length()const;//求表长度LinkNode<T> *getHead()const {return first;}//取表头结点指针LinkNode<T> *Search(T x);//搜索数据域为x的结点LinkNode<T> *Locate(int i)const;//取i号表项的地址bool getData(int i,T &x)const;//取i号表项的数据void setData(int i,T &x);//用x修改第i个元素的值bool Insert(int i,T &x);//在第i个元素后插入xbool Remove(int i,T &x);//删除第i个元素，x返回该元素的值bool IsEmpty()const//判断表空否，空则返回true{return first->link==NULL?true:false;}void Output();//输出void Turn();//将单链表的指向倒转void Combine(LinkedList<T> &A,LinkedList<T> &B);//将两个单链表合并void Divide(LinkedList<T> &D,LinkedList<T> &E); protected:LinkNode<T> *first;};template<class T>//复制构造函数实现LinkedList<T>::LinkedList(LinkedList<T> &L){T value;LinkNode<T> *srcptr = L.getHead();LinkNode<T> *destptr = first = new LinkNode<T>;while (srcptr->link!=NULL){value = srcptr->link->data;destptr->link = new LinkNode<T>(value);srcptr = srcptr->link;destptr = destptr->link;}destptr->link = NULL;}template<class T>//置空函数实现void LinkedList<T>::makeEmpty(){LinkNode<T> *p;while (first->link!=NULL){p = first->link;first->link = p->link;delete p;}}template<class T>//求长函数实现int LinkedList<T>::Length()const{LinkNode<T> *p = first->link;int count = 0;while (p!=NULL){p = p->link;count++;}return count;}template<class T>//搜索函数实现LinkNode<T> *LinkedList<T>::Search(T x){LinkNode<T> *current = first->link;while (current!=NULL){if (current->data==x)break;elsecurrent = current->link;return current;}}template<class T>//定位函数实现LinkNode<T> *LinkedList<T>::Locate(int i)const {if (i<0)return NULL;LinkNode<T> *current = first;int k = 0;while (current!=NULL&&k<i){current = current->link;k++;}return current;}template<class T>//取值函数实现bool LinkedList<T>::getData(int i,T &x)const {if (i<=0)return NULL;LinkNode<T> *current = Locate(i);if (current==NULL)return false;else{x = current->data;return true;}}template<class T>//修改函数实现void LinkedList<T>::setData(int i,T &x) {if (i<=0)return;LinkNode<T> *current = Locate(i);if (current==NULL)return;elsecurrent->data = x;}template<class T>//插入函数实现bool LinkedList<T>::Insert(int i,T &x){LinkNode<T> *current = Locate(i);if (current==NULL)return false;LinkNode<T> *newNode = new LinkNode<T>(x);newNode->link = current->link;current->link = newNode;return true;}template<class T>//删除函数实现bool LinkedList<T>::Remove(int i,T &x){LinkNode<T> *current = Locate(i-1);if (current==NULL||current->link==NULL)return false;LinkNode<T> *del = current->link;x = del->data;delete del;return true;}template<class T>//输出函数实现void LinkedList<T>::Output(){LinkNode<T> *current = first->link;while (current!=NULL){cout<<current->data<<'\t';current = current->link;}cout<<endl;}template<class T>//倒置函数实现void LinkedList<T>::Turn(){if (first->link==NULL)return;LinkNode<T> *current1 = first->link,*current2 = first->link->link;LinkNode<T> *p;while(p!=NULL){p = current2->link;current2->link = current1;current1 = current2;current2 = p;}first->link->link = NULL;//让倒置后的最后一个结点的指针域为空first->link = current1;//让附加的表头结点的指针域指向第一个结点}template<class T>void LinkedList<T>::Combine(LinkedList<T> &A,LinkedList<T> &B) //合并函数{T value1,value2;LinkNode<T> *srcptr1 = A.getHead();LinkNode<T> *srcptr2 = B.getHead();LinkNode<T> *destptr = first = new LinkNode<T>;if (A.Length()<B.Length()){while (srcptr1->link!=NULL){value1 = srcptr1->link->data;value2 = srcptr2->link->data;destptr->link = new LinkNode<T>(value1);srcptr1 = srcptr1->link;destptr = destptr->link;destptr->link = new LinkNode<T>(value2);srcptr2 = srcptr2->link;destptr = destptr->link;}while (srcptr2->link!=NULL){value2 = srcptr2->link->data;destptr->link = new LinkNode<T>(value2);srcptr2 = srcptr2->link;destptr = destptr->link;}destptr->link = NULL;}if (A.Length()==B.Length()){while (srcptr2->link!=NULL){value1 = srcptr1->link->data;value2 = srcptr2->link->data;destptr->link = new LinkNode<T>(value1);srcptr1 = srcptr1->link;destptr = destptr->link;destptr->link = new LinkNode<T>(value2);srcptr2 = srcptr2->link;destptr = destptr->link;}destptr->link = NULL;}if (A.Length()>B.Length()){while (srcptr2->link!=NULL){value1 = srcptr1->link->data;value2 = srcptr2->link->data;destptr->link = new LinkNode<T>(value1);srcptr1 = srcptr1->link;destptr = destptr->link;destptr->link = new LinkNode<T>(value2);srcptr2 = srcptr2->link;destptr = destptr->link;}while (srcptr1->link!=NULL){value1 = srcptr1->link->data;destptr->link = new LinkNode<T>(value1);srcptr2 = srcptr2->link;destptr = destptr->link;}destptr->link = NULL;}}template<class T>void LinkedList<T>::Divide(LinkedList<T> &D,LinkedList<T> &E) {T value;LinkNode<T> *srcptr = this->getHead();LinkNode<T> *destptr1 = D.first = new LinkNode<T>;LinkNode<T> *destptr2 = E.first = new LinkNode<T>;while (srcptr->link!=NULL&&srcptr->link->link!=NULL){value = srcptr->link->data;destptr1->link = new LinkNode<T>(value);srcptr = srcptr->link->link;destptr1 = destptr1->link;}destptr1->link = NULL;srcptr = this->getHead();srcptr = srcptr->link;while (srcptr->link!=NULL&&srcptr->link->link!=NULL) {value = srcptr->link->data;destptr2->link = new LinkNode<T>(value);srcptr = srcptr->link->link;destptr2 = destptr2->link;}destptr1->link = NULL;}#endif节点头文件：LinkNode.h：#ifndef LINKNODE_H#define LINKNODE_H#include <iostream.h>template<class T>struct LinkNode{T data;//数据域LinkNode<T> *link;//指针域LinkNode<T>(LinkNode<T> *ptr = NULL){link = ptr;}//仅有指针域形参的构造函数LinkNode<T>(const T &item,LinkNode<T> *ptr = NULL)//构造函数{data = item;link = ptr;}};#endif主函数源文件：Main.cpp:#include <iostream.h>#include "LinkedList.h"#include "LinkNode.h"void main(){LinkedList<int> List1,List2,List3,List4,List5;int a[] = {1,2,3,4,5,6,7,8,9,10};int b[] = {1,2,3,4,5,6,7,8,9,10,11,12};for (int i = 0;i<10;i++)List1.Insert(i,b[i]);for (int j = 0;j<12;j++)List2.Insert(j,b[j]);cout<<"逆转前："<<endl;cout<<"List1: ";List1.Output();cout<<"List2: ";List2.Output();cout<<"List3为List1与List2的合并链表。