数据结构课程设计实验报告
数据结构课程设计实验报告完整版
数据结构课程设计实验报告完整版【正文】一、实验目的本实验主要目的是通过实践，掌握数据结构的基本概念、常见数据结构的实现方式以及在实际应用中的应用场景和效果。
二、实验背景数据结构是计算机科学与技术领域中的一个重要概念，是研究数据的组织方式、存储方式、访问方式以及操作等方面的方法论。
在计算机科学领域，数据结构是实现算法和解决问题的基础，因此对数据结构的理解和应用具有重要意义。
三、实验内容本次数据结构课程设计实验主要分为以下几个部分：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、结果分析经过测试和验证，该学生成绩管理系统能够满足设计目标，并能够正常运行。
- 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的合并链表。