淮海工学院数据结构第一次实验报告

合集下载

淮海工学院大数据结构第一次实验资料报告材料

淮海工学院计算机科学系实验报告书课程名：《数据结构》题目：线性数据结构试验班级：软嵌151学号： 2015123352姓名：吉线性表实验报告要求1目的与要求:1）掌握线性表数据结构的基本概念和抽象数据类型描述；2）熟练掌握线性表数据结构的顺序和链式存储存表示；3）熟练掌握线性表顺序存储结构的基本操作算法实现；4）熟练掌握线性表的链式存储结构的基本操作算法实现;5）掌握线性表在实际问题中的应用和基本编程技巧;6）按照实验题目要求独立正确地完成实验容（提交程序清单及相关实验数据与运行结果）；7）按照报告格式和容要求，认真书写实验报告，并于下周周二前统一提交实验报告电子版文档（每次实验全体同学必须提交实验报告电子版，实验报告文档文件命名方式：+学号+数据结构第X次实验报告）提交给学委，而后由学委以班为单位统一打包（包文件名为：软件14X 班-数据结构第X次实验报告）用发给老师；提交纸质报告（每班每次收5份，学委安排，保证每学期每个同学至少提交一次）一起提交给老师。

每次提交电子文档时，学委务必统计和上报未交报告人数和具体；凡逾期不交报告者，不再推迟提交，一律按照旷交处理。

8）积极开展实验组组交流和辅导，严禁直接复制和剽窃他人实验成果，一旦发现严肃处理；9）上实验课前，要求每个同学基本写好程序，并存储在自己的U盘上，用于实验课堂操作时调试和运行。

2实验容或题目（在一个主程序中实现全部题目容）一、顺序表的基本操作实现实验要求：数据元素类型ElemType取整型int。

按照顺序存储结构实现如下算法：1）创建任意整数线性表（即线性表的元素值随机在键盘上输入）的顺序存储结构（即顺序表），长度限定在25之；2）打印/显示（遍历）该线性表（依次打印/显示出表中元素值）；3）在顺序表中查找第i个元素，并返回其值；4）在顺序表第i个元素之前插入一已知元素；5）在顺序表中删除第i个元素；6）求顺序表中所有元素值（整数）之和；二、链表（带头结点）基本操作实验要求：数据元素类型ElemType取字符型char。

数据结构实验报告一

数据结构实验报告一数据结构实验报告一一、引言数据结构是计算机科学中非常重要的一门课程，它研究的是数据的组织、存储和管理方式。

在本次实验中，我们将学习并实践一些常用的数据结构，包括数组、链表和栈。

通过实验，我们将深入理解这些数据结构的原理和应用。

二、实验目的本次实验的目的是通过编写代码实现一些常用的数据结构，并测试它们的功能和性能。

通过实际操作，我们将掌握这些数据结构的基本操作和使用方法。

三、实验过程1. 数组数组是一种线性数据结构，它由一组连续的存储单元组成。

在本次实验中，我们将实现一个动态数组，它可以根据需要自动调整大小。

我们首先定义一个数组类，包含插入、删除和查找等基本操作。

然后，我们编写测试代码，验证数组的功能和性能。

2. 链表链表是另一种常用的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

在本次实验中，我们将实现一个单向链表。

我们首先定义一个节点类，然后定义一个链表类，包含插入、删除和查找等基本操作。

最后，我们编写测试代码，验证链表的功能和性能。

3. 栈栈是一种特殊的线性数据结构，它只能在一端进行插入和删除操作。

栈的特点是后进先出（LIFO）。

在本次实验中，我们将实现一个栈。

我们首先定义一个栈类，包含入栈、出栈和查看栈顶元素等基本操作。

然后，我们编写测试代码，验证栈的功能和性能。

四、实验结果通过实验，我们成功实现了动态数组、单向链表和栈的基本操作。

我们编写了测试代码，并对这些数据结构的功能和性能进行了验证。

实验结果表明，这些数据结构在不同场景下都有很好的表现，并且可以满足我们的需求。

五、实验总结本次实验让我们更加深入地理解了数据结构的原理和应用。

通过实际编写代码并进行测试，我们掌握了数组、链表和栈等常用数据结构的基本操作和使用方法。

实验过程中，我们遇到了一些问题，但通过不断的调试和优化，最终成功解决了这些问题。

通过本次实验，我们不仅提高了编程能力，也增强了对数据结构的理解和应用能力。

数据结构实训实验报告

一、实验背景数据结构是计算机科学中一个重要的基础学科，它研究如何有效地组织和存储数据，并实现对数据的检索、插入、删除等操作。

为了更好地理解数据结构的概念和原理，我们进行了一次数据结构实训实验，通过实际操作来加深对数据结构的认识。

二、实验目的1. 掌握常见数据结构（如线性表、栈、队列、树、图等）的定义、特点及操作方法。

2. 熟练运用数据结构解决实际问题，提高算法设计能力。

3. 培养团队合作精神，提高实验报告撰写能力。

三、实验内容本次实验主要包括以下内容：1. 线性表（1）实现线性表的顺序存储和链式存储。

（2）实现线性表的插入、删除、查找等操作。

2. 栈与队列（1）实现栈的顺序存储和链式存储。

（2）实现栈的入栈、出栈、判断栈空等操作。

（3）实现队列的顺序存储和链式存储。

（4）实现队列的入队、出队、判断队空等操作。

3. 树与图（1）实现二叉树的顺序存储和链式存储。

（2）实现二叉树的遍历、查找、插入、删除等操作。

（3）实现图的邻接矩阵和邻接表存储。

（4）实现图的深度优先遍历和广度优先遍历。

4. 算法设计与应用（1）实现冒泡排序、选择排序、插入排序等基本排序算法。

（2）实现二分查找算法。

（3）设计并实现一个简单的学生成绩管理系统。

四、实验步骤1. 熟悉实验要求，明确实验目的和内容。

2. 编写代码实现实验内容，对每个数据结构进行测试。

3. 对实验结果进行分析，总结实验过程中的问题和经验。

4. 撰写实验报告，包括实验目的、内容、步骤、结果分析等。

五、实验结果与分析1. 线性表（1）顺序存储的线性表实现简单，但插入和删除操作效率较低。

（2）链式存储的线性表插入和删除操作效率较高，但存储空间占用较大。

2. 栈与队列（1）栈和队列的顺序存储和链式存储实现简单，但顺序存储空间利用率较低。

（2）栈和队列的入栈、出队、判断空等操作实现简单，但需要考虑数据结构的边界条件。

3. 树与图（1）二叉树和图的存储结构实现复杂，但能够有效地表示和处理数据。

数据结构实验报告

数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践，掌握基本的数据结构概念、原理及其应用，培养学生的问题分析与解决能力，提升编程实践能力。

二、实验背景数据结构是计算机科学中的重要基础，它研究数据的存储方式和组织形式，以及数据之间的关系和操作方法。

在软件开发过程中，合理选用和使用数据结构，能够提高算法效率，优化内存利用，提升软件系统的性能和稳定性。

三、实验内容本次实验主要涉及以下几个方面的内容：1.线性表的基本操作：包括线性表的创建、插入、删除、查找、修改等操作。

通过编程实现不同线性表的操作，掌握它们的原理和实现方法。

2.栈和队列的应用：栈和队列是常用的数据结构，通过实现栈和队列的基本操作，学会如何解决实际问题。

例如，利用栈实现括号匹配，利用队列实现银行排队等。

3.递归和回溯算法：递归和回溯是解决很多求解问题的常用方法。

通过编程实现递归和回溯算法，理解它们的思想和应用场景。

4.树和二叉树的遍历：学习树和二叉树的遍历方法，包括前序、中序和后序遍历。

通过编程实现这些遍历算法，加深对树结构的理解。

5.图的基本算法：学习图的基本存储结构和算法，包括图的遍历、最短路径、最小生成树等。

通过编程实现这些算法，掌握图的基本操作和应用。

四、实验过程1.具体实验内容安排：根据实验要求，准备好所需的编程环境和工具。

根据实验要求逐步完成实验任务，注意记录并整理实验过程中遇到的问题和解决方法。

2.实验数据采集和处理：对于每个实验任务，根据要求采集并整理测试数据，进行相应的数据处理和分析。

记录实验过程中的数据和结果。

3.实验结果展示和分析：将实验结果进行适当的展示，例如表格、图形等形式，分析实验结果的特点和规律。

4.实验总结与反思：总结实验过程和结果，回顾实验中的收获和不足，提出改进意见和建议。

五、实验结果与分析根据实验步骤和要求完成实验任务后，得到了相应的实验结果。

对于每个实验任务，根据实验结果进行适当的分析。

数据结构实验报告及心得体会

数据结构实验报告及心得体会一、概述：介绍本次实验的目的、背景以及所使用的实验环境和工具。

本次实验旨在通过实际操作，深入理解和掌握数据结构的原理及应用。

实验背景源于课程学习的理论知识与实际应用相结合的需求，通过实验操作，期望能够将课堂所学的数据结构知识更好地运用到实际编程和解决现实问题中。

本次实验所使用的实验环境为先进的计算机实验室，配备了高性能的计算机硬件和丰富的软件开发工具。

为了完成实验，我使用了Java编程语言，并结合Eclipse开发环境进行编程和调试。

我还参考了相关的数据结构专业书籍和在线资源，以便更好地理解和应用数据结构知识。

在实验过程中，我严格按照实验指导书的步骤进行操作，并认真记录了实验数据和结果。

通过本次实验，我深刻体会到了数据结构的重要性，也对数据结构的实现和应用有了更深入的了解。

二、实验内容：分别介绍线性数据结构（线性表）、非线性数据结构（二叉树、图）的实验内容，包括其实现方法、操作过程等。

每个实验都包含具体的实验目的和预期结果。

三、实验过程及结果分析：详细描述实验过程，包括实验步骤的执行情况，遇到的问题及解决方法。

对实验结果进行展示，并进行数据分析和结论。

这部分是实验报告的核心部分，体现了学生的实践能力和问题解决能力。

四、心得体会：分享在实验过程中的心得体会，包括遇到的困难、收获，对数据结构的理解与认识提升，以及实验过程中的团队协作和学习体验等。

这部分内容可以体现出学生的思考深度和学习的主观感受。

五、总结与展望：对本次实验报告进行总结，并对未来数据结构与算法的学习提出展望和建议。

这部分内容可以帮助学生梳理所学知识，明确未来的学习方向。

数据结构实验一实验报告

班级：姓名：学号：实验一线性表的基本操作一、实验目的1、掌握线性表的定义；2、掌握线性表的基本操作，如成立、查找、插入和删除等。

二、实验内容定义一个包括学生信息（学号，姓名，成绩）的次序表和链表（二选一），使其拥有以下功能：(1)依据指定学生个数，逐一输入学生信息；(2)逐一显示学生表中全部学生的有关信息；(3)依据姓名进行查找，返回此学生的学号和成绩；(4)依据指定的地点可返回相应的学生信息（学号，姓名，成绩）；(5)给定一个学生信息，插入到表中指定的地点；(6)删除指定地点的学生记录；(7)统计表中学生个数。

三、实验环境Visual C++四、程序剖析与实验结果#include<>#include<>#include<>#include<>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;结构链表");puts("2. 录入学生信息 ");puts("3. 显示学生信息 ");puts("4. 输入姓名，查找该学生");puts("5. 显示某地点该学生信息");puts("6. 在指定地点插入学生信息");puts("7. 在指定地点删除学生信息");puts("8. 统计学生个数 ");puts("0. 退出 ");printf("\n********************************\n\n");int x,choose=-1;while(choose!=0){puts(" 请选择 :");scanf("%d",&choose);switch(choose){case 1:if(InitList(p))printf(" 成功成立链表 \n\n");elseprintf(" 链表成立失败 \n\n");break;case 2:printf(" 请输入要录入学生信息的人数:");scanf("%d",&x);for(int i=1;i<=x;i++){printf(" 第%d个学生 :\n",i);Input(&a);ListInsert(&L,i,a);}break;case 3:for(int i=1;i<=x;i++){GetElem(&L,i,b);Output(&b);}break;case 4:char s[20];printf(" 请输入要查找的学生姓名:");scanf("%s",s);if(Search(L,s,p))Output(&(p->data));elseputs(" 对不起，查无这人 ");puts("");break;case 5:printf(" 请输入要查问的地点 :");int id1;scanf("%d",&id1);GetElem(&L,id1,c);Output(&c);break;case 6:printf ("请输入要插入的地点:");int id2;scanf("%d",&id2);printf(" 请输入学生信息 :\n");Input(&d);if(ListInsert(&L,id2,d)){x++;puts(" 插入成功 ");puts("");}else{puts(" 插入失败 ");puts("");}break;case 7:printf(" 请输入要删除的地点 :");int id3;scanf("%d",&id3);if(ListDelete(&L,id3)){x--;puts(" 删除成功 ");puts("");}else{puts(" 删除失败 ");puts("");}break;case 8:printf(" 已录入的学生个数为 :%d\n\n",x);break;}}printf("\n\n感谢您的使用，请按随意键退出\n\n\n");system("pause");return 0;}用户界面 :(1)依据指定学生个数，逐一输入学生信息：(2)逐一显示学生表中全部学生的有关信息：(3)依据姓名进行查找，返回此学生的学号和成绩：(4) 依据指定的地点可返回相应的学生信息（学号，姓名，成绩）：(5)给定一个学生信息，插入到表中指定的地点：(6)删除指定地点的学生记录：(7)统计表中学生个数：五、实验总结数据结构是一门专业技术基础课。

查找、排序的应用实验1

淮海工学院计算机科学系实验报告书课程名：《数据结构》题目：查找、排序的应用实验班级：软件081学号：110831123姓名：XX排序、查找的应用实验报告要求1目的与要求:1）查找、排序是日常数据处理过程中经常要进行的操作和运算，掌握其算法与应用对于提高学生数据处理能力和综合应用能力显得十分重要。

2）本次实验前，要求同学完整理解有关排序和查找的相关算法和基本思想以及种算法使用的数据存储结构；3）利用C或C++语言独立完成本次实验内容或题目，程序具有良好的交互性（以菜单机制实现实验程序的交互运行）和实用性；4）本次与第七次实验已合二为一，实验结果在机房现场验收和评分，希望同学们认真对待，并于2009年12月20日按时提交本次实验报告（含电子和纸质报告），任何同学不得拖延。

5）如果验收时间紧张，不能再正课时间完成者，由老师择机决定另行通知专门验收时间。

凡无故不主动或拖延验收者，均按照不及格处理。

5）认真书写实验报告（包括程序清单及相关实验数据与完整运行结果），并于按时提交。

2 实验内容或题目题目：对数据序列（查找表）：{55，13，23，72，109，67，2，78,13}分别实现如下操作：1)顺序查找；2)分别使用直接插入排序、冒泡排序、快速排序对原纪录序列进行排序；3)对排好序的纪录序列表进行折半查找；4)利用原纪录序列建立一颗二叉排序树，并在其上实现特定关键字值结点的查找；5)按照“除留余数法”哈希构造函数和线性探测再散列的冲突处理方法创建表长为m=11的哈希表；6)实现5）创建哈希表上的查找。

7）分别简单选择排序、堆排序、链式基数排序算法对数据序列进行排序，并显示排序结果。

3 实验步骤与源程序#include <stdio.h>#include <stdlib.h>#include<malloc.h>#include <math.h>#define LIST_SIZE 20#define KEY_SIZE 6#define RADIX 10#define TRUE 1#define FALSE 0#define SUCCESS 1#define UNSUCCESS -1#define MAX 20typedef char KeyType;typedef int OtherType;typedef struct{KeyType key;OtherType other_data;}RecordType;typedef struct{KeyType key[KEY_SIZE];int type;int next;}RecordType1;typedef struct{RecordType1 R[LIST_SIZE+1];int length;int keynum;}SLinkList;typedef int PVector[RADIX];typedef struct{RecordType r[LIST_SIZE+1]; /* r[0]为工作单元 */ int length;}RecordList;//二叉排序树的创建与查找#define ENDKEY 0typedef struct node{KeyType key ; /*关键字的值*/struct node *lchild,*rchild;/*左右指针*/}BSTNode, *BSTree;/*哈希表的创建*/typedef struct{int key;int flag;//falg=1时表示有关键字，=0时表示没有关键字}Elemtype;typedef struct{Elemtype *elem;//动态分配的哈希表的首地址int sizeindex;//hashsize[sizeindex]为当前容量int count;//当前数据元素个数}HashTable;/*顺序查找*/void SeqSearch(RecordList l, KeyType k)/*在顺序表l中顺序查找其关键字等于k的元素，若找到，则函数值为该元素在表中的位置，否则为0*/{int i;l.r[0].key=k;i=l.length;while (l.r[i].key!=k) i--;if (i>=1){printf("该元素k所在的位置是:");printf("%d",i);}elseprintf("该元素不存在");}//直接插入排序void InsSort(RecordType r[], int length)/* 对记录数组r做直接插入排序，length为数组中待排序记录的数目*/{int i,j;for (i=2; i<=length; i++){r[0]=r[i]; /*将待插入记录存放到监视哨r[0]中*/j=i-1;while (r[0].key< r[j].key ) /* 寻找插入位置 */{r[j+1]= r[j];j=j-1;}r[j+1]=r[0]; /*将待插入记录插入到已排序的序列中*/}} /* InsSort *//*冒泡排序*/void BubbleSort(RecordType r[],int length)/*对记录数组r做冒泡排序，length为数组的长度*/{int x,i,n,change,j;n=length;change=TRUE;for(i=1;i<=n-1&&change;++i){change=FALSE;for(j=1;j<=n-i;++j)if(r[j].key>r[j+1].key){x=r[j].key;r[j]=r[j+1];r[j+1].key=x;change=TRUE;}}}//快速排序int Partition(RecordList &L,int low,int high) //Partition() sub-function { int pivotkey;L.r[0]=L.r[low];pivotkey=L.r[low].key;while(low<high){ while(low<high&&L.r[high].key>=pivotkey)--high;L.r[low]=L.r[high];while(low<high&&L.r[low].key<=pivotkey)++low;L.r[high]=L.r[low];}L.r[low]=L.r[0];return(low);} //Partition() endvoid Qsort(RecordList &L,int low,int high) //Qsort() sub-function{ int pivotloc;if(low<high){ pivotloc=Partition(L,low,high);Qsort(L,low,pivotloc-1);Qsort(L,pivotloc+1,high);}}void QuickSort(RecordList &L) //QuickSort() sub-function{ Qsort(L,1,L.length); //call Qsort()}/*对排好的序进行折半查找算法*/void BinSrch(RecordList l,KeyType k)/*在有序表l中折半查找其关键字等于k的元素，若找到，则函数值为该元素在表中的位置*/{int low,high,mid;low=1;high=l.length;/*置区间初值*/while(low<=high){mid=(low+high)/2;if (k==l.r[mid].key){printf("找到该元素，其位置为%d",mid);break;}/*找到待查元素*/elseif (k<l.r[mid]. key)high=mid-1;/*未找到，则继续在前半区间进行查找*/ elselow=mid+1;/*继续在后半区间进行查找*/}if(low>high) printf("没有找到该元素");}void InsertBST(BSTree *bst, KeyType key)/*若在二叉排序树中不存在关键字等于key的元素，插入该元素*/{BSTree s;if (*bst == NULL)/*递归结束条件*/{s=(BSTree)malloc(sizeof(BSTNode));/*申请新的结点s*/s-> key=key;s->lchild=NULL;s->rchild=NULL;*bst=s;}elseif (key < (*bst)->key)InsertBST(&((*bst)->lchild), key);/*将s插入左子树*/ elseif (key > (*bst)->key)InsertBST(&((*bst)->rchild), key); /*将s插入右子树*/ }void CreateBST(BSTree *bst)/*从键盘输入元素的值，创建相应的二叉排序树*/{KeyType key;*bst=NULL;scanf("%d", &key);while (key!=ENDKEY) /*ENDKEY为自定义常量*/{InsertBST(bst, key);scanf("%d", &key);}}void PreOrder(BSTree root)/*先序遍历二叉树, root为指向二叉树根结点的指针*/{if (root!=NULL){printf("%d ",root->key); /*输出结点*/PreOrder(root->lchild); /*先序遍历左子树*/PreOrder(root->rchild); /*先序遍历右子树*/}}BSTree SearchBST(BSTree bst, KeyType key)/*在根指针bst所指二叉排序树中，递归查找某关键字等于key的元素，若查找成功，返回指向该元素结点指针，否则返回空指针*/{if (!bst)return NULL;elseif (bst->key == key)return bst;/*查找成功*/elseif (bst->key > key)return SearchBST(bst->lchild, key);/*在左子树继续查找*/elsereturn SearchBST(bst->rchild, key);/*在右子树继续查找*/}BSTNode * DelBST(BSTree t, KeyType k) /*在二叉排序树t中删去关键字为k的结点*/{BSTNode *p, *f,*s ,*q;p=t;f=NULL;while(p) /*查找关键字为k的待删结点p*/{if(p->key==k ) break; /*找到则跳出循环*/f=p; /*f指向p结点的双亲结点*/if(p->key>k)p=p->lchild;elsep=p->rchild;}if(p==NULL) return t; /*若找不到，返回原来的二叉排序树*/if(p->lchild==NULL) /*p无左子树*/{if(f==NULL)t=p->rchild; /*p是原二叉排序树的根*/elseif(f->lchild==p) /*p是f的左孩子*/f->lchild=p->rchild ; /*将p的右子树链到f的左链上*/ else /*p是f的右孩子*/f->rchild=p->rchild ; /*将p的右子树链到f的右链上*/ free(p); /*释放被删除的结点p*/}else /*p有左子树*/{q=p;s=p->lchild;while(s->rchild) /*在p的左子树中查找最右下结点*/{q=s;s=s->rchild;}if(q==p)q->lchild=s->lchild ; /*将s的左子树链到q上*/ elseq->rchild=s->lchild;p->key=s->key; /*将s的值赋给p*/free(s);}return t;} /*DelBST*//*建立哈希表*/int CreatHashTable(HashTable &H,int m){int i,keys,p,len;H.elem = (Elemtype *)malloc(MAX * sizeof(Elemtype));H.sizeindex = MAX;//初始存储容量H.count=0;printf("请输入该组关键字的个数:");scanf("%d",&m);printf("请输入表长len:");scanf("%d",&len);H.sizeindex = len;for(i = 0;i < m;++i){H.elem[i].flag = 0;printf("请输入该组关键字：");for(i = 0;i < m;++i){scanf("%d",&keys);p = keys %m;while(H.elem[p].flag == 1)//处理冲突{int d=1;p = (p +d)% m;d++;}H.elem[p].key = keys;H.elem[p].flag = 1;H.count++;}for(int j=H.count;j<len;j++)H.elem[j].key=0;printf("哈希表创建完毕！\n");printf("下标关键字\n");for(i = 0;i<len;i++){printf("%d ",i);printf("%d",H.elem[i].key);printf("\n");}return SUCCESS;}void SearchHashTable(HashTable H){int keys,p;printf("请输入您要查找的关键字：\n");scanf("%d",&keys);for(int i=0;i<H.count;i++){if( keys == H.elem[i].key)//p是找到的关键字的下标{p=i;}}if(p>-1&&p<H.count){printf("查找成功！\n");printf("该关键字在哈希表中的下标为：%d \n",p); }elseprintf("查找失败，表中无此关键字！\n");/*简单选择排序*/void SelectSort(RecordType r[],int length)/*对记录数组r做简单选择排序，length为数组的长度*/{int i,j,k,x,n=length;for(i=1;i<=n-1;++i){k=i;for(j=i+1;j<=n;++j)if(r[j].key<r[k].key) k=j;if(k!=i){x=r[i].key;r[i]=r[k];r[k].key=x;}}}/*筛选算法*/void sift(RecordType r[],int k,int m)/*假设r[k..m]是以r[k]为根的完全二叉树，且分别以r[2k]和r[2k+1]为根的左右子树为大根堆，调整r[k],使整个序列r[k..m]满足堆的性质*/{int i,t,j,x,finished;t=r[k].key;x=r[k].key;i=k;j=2*i;finished=FALSE;while(j<=m&&!finished){if(j<m&&r[j].key<r[j+1].key) j=j+1;/*若存在右子树，且右子树的关键字大，则沿右分支“筛选”*/if(x>=r[j].key) finished=TRUE; /*筛选完毕*/else{r[i]=r[j];i=j;j=2*i;} /*继续筛选*/}r[i].key=t;/*r[k]填入到恰当位置*/}/*建立堆*/void crt_heap(RecordType r[],int length)/*对记录数组r建堆，length为数组的长度*/{int i,n=length;for(i=n/2;i>=1;--i) /*自第n/2个记录开始进行筛选建堆*/sift(r,i,n);}/*堆排序*/void HeapSort(RecordType r[],int length)/*对r[1..n]进行堆排序，执行本算法后，r中记录按关键字由大到小有序排列*/ {crt_heap(r,length);int i,b,n=length;for(i=n;i>=2;--i){b=r[1].key; /*将堆顶记录和堆中的最后一个记录互换*/r[1]=r[i];r[i].key=b;sift(r,1,i-1); /*进行调整，使r[1..i-1]变成堆*/}}//链式基数排序void Distribute (SLinkList *L,int i,PVector head,PVector tail){int j,p;for(j=0;j<=RADIX-1;++j)head[j]=0;p=L->R[0].next;while(p){j=L->R[p].key[i];if(head[j]==0) head[j]=p;else L->R[tail[j]].next=p;tail[j]=p;p=L->R[p].next;}}void Collect(SLinkList *L,PVector head,PVector tail){int j=0,t;while(head[j]==0)++j;L->R[0].next=head[j];t=tail[j];while(j<RADIX-1){++j;while((j<RADIX-1)&&(head[j]==0))++j;if(head[j]!=0){L->R[t].next=head[j];t=tail[j];}}L->R[t].next=0;}void RadixSort(SLinkList *L ){int n,i,d,j,x,k;printf("输入链表长度 :");scanf("%d",&(L->length));printf("输入最大位数 :");scanf("%d",&(L->keynum));PVector head,tail;n=L->length;for(i=0;i<=n-1;++i) L->R[i].next=i+1; L->R[n].next=0;printf("输入各记录 :");for(j=1;j<=L->length;j++){scanf("%d",&(L->R[j].type));}for(i=1;i<=L->length;i++){x=L->R[i].type;for(j=0;j<L->keynum;j++){L->R[i].key[j]=x%10;x=x/10;}}d=L->keynum;for(i=0;i<L->keynum;++i){Distribute(L,i,head,tail);Collect(L,head,tail);}k=0;printf("排序后为 :");while(L->R[k].next){printf("%d ",L->R[L->R[k].next].type);k=L->R[k].next;}}void main(){int i,j,select,a,flag=1,m=0;printf("1 记录序列 \n2 进行顺序查找 \n3 进行直接排序 \n4 进行冒泡排序 \n5 进行快速排序 \n6进行简单选择排序并输出 \n7进行堆排序并输出 \n");printf("\n8 进行链式基数排序并输出 \n9 对排好序的纪录序列表进行折半查找 \n10 利用原纪录序列建立一颗二叉排序树，并在其上实现特定关键字值结点的查找 \n11 建立哈希表，并对其进行查找 \n12 退出");RecordType r[20];BSTree bst,result,T;RecordList L,Q;int length,k,low;while(flag){printf("请选择：");scanf("%d",&a);switch(a){case 1:printf("请输入待排序记录的长度:"); //交互创建纪录表scanf("%d",&length);for(i=1;i<=length;i++){printf("请输入第%d个记录元素:",i);fflush(stdin);scanf("%d",&j);r[i].key = j;}printf("你输入的各元素为：");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 2:printf("请输入你要查找的元素k：");fflush(stdin);scanf("%d",&k);L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}SeqSearch(L,k);printf("\n");break;case 3:InsSort(r,length);printf("按直接排序后各元素为：");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 4:BubbleSort(r,length);printf("按冒泡排序后各元素为：");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 5:L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}QuickSort(L);printf("进行快速排序后各元素为: ");for(i=1;i<=L.length;i++)printf("%d ",L.r[i].key);printf("\n");break;case 6: SelectSort(r,length);printf("按简单选择排序后各元素为：");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 7: HeapSort(r,length);printf("按堆排序后各元素为：");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 8: SLinkList l;RadixSort(&l);printf("\n");break;case 9:InsSort(r,length);L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}printf("请输入要查找的元素:");scanf("%d",&k);BinSrch(L,k);printf("\n");break;case 10:int k;printf("建立二叉排序树，请输入序列（以0结束）:\n"); CreateBST(&T);printf("先序遍历输出序列为:");PreOrder(T);printf("\n请输入要查找的元素:");fflush(stdin);scanf("%d",&k);result = SearchBST(T,k);if (result != NULL)printf("存在要查找的元素为%d\n",result->key);elseprintf("未找到!\n");result = DelBST(T,k);// getch();break;case 11:HashTable H;CreatHashTable(H,m);SearchHashTable(H);break;case 12:flag=0;}}}4 测试数据与实验结果（可以抓图粘贴）简单选择排序、堆排序与基数排序，见下图：5 结果分析与实验体会在这次试验中的第7题中前两个排序：简单选择排序与堆排序都直接从书上摘下来的，可对于基数排序，还需要自己写点，比如Order函数，在这里我没有直接调用，他表示用记录中的第i位关键字求相应队列号，而是写在了RadixSort函数中。

数据结构第一次实验报告

数据结构第一次实验报告实验报告：数据结构第一次实验摘要：本次实验旨在通过实践操作，加深对数据结构的理解，并掌握数据结构的基本操作。

实验中，我们使用C++编程语言实现了链表、栈和队列的相关操作，并对其进行了测试和分析。

实验结果表明，我们成功地完成为了链表、栈和队列的实现，并验证了它们的正确性和效率。

1. 引言数据结构是计算机科学中的重要基础课程，它研究数据的组织方式和存储结构，以及对数据进行操作和处理的方法。

本次实验旨在通过实践操作，加深对数据结构的理解，并掌握数据结构的基本操作。

2. 实验目的- 熟悉链表、栈和队列的基本概念；- 掌握链表、栈和队列的基本操作；- 分析链表、栈和队列的时间复杂度。

3. 实验方法3.1 链表的实现我们使用C++编程语言实现了链表的基本操作，包括创建链表、插入节点、删除节点和打印链表等。

具体实现过程如下：- 定义一个链表节点结构体，并在结构体中定义节点的数据域和指针域；- 创建链表，即定义一个头节点，并设置头节点的指针域为空；- 插入节点，即在链表中指定位置插入一个新节点；- 删除节点，即删除链表中指定位置的节点；- 打印链表，即遍历链表并输出节点的数据。

3.2 栈的实现我们使用C++编程语言实现了栈的基本操作，包括入栈、出栈和判断栈是否为空等。

具体实现过程如下：- 定义一个栈结构体，并在结构体中定义一个数组和一个指针top，用于存储栈元素和指示栈顶位置；- 入栈，即将一个元素压入栈中，同时将指针top向上挪移一个位置；- 出栈，即将栈顶元素弹出栈，同时将指针top向下挪移一个位置；- 判断栈是否为空，即判断指针top是否指向栈底。

3.3 队列的实现我们使用C++编程语言实现了队列的基本操作，包括入队、出队和判断队列是否为空等。

具体实现过程如下：- 定义一个队列结构体，并在结构体中定义一个数组、一个指针front和一个指针rear，用于存储队列元素和指示队首和队尾位置；- 入队，即将一个元素插入队列尾部，同时将指针rear向后挪移一个位置；- 出队，即将队首元素删除，同时将指针front向后挪移一个位置；- 判断队列是否为空，即判断指针front和指针rear是否相等。

图形数据结构实验

图形数据结构实验淮海⼯学院计算机科学系实验报告书课程名：《数据结构》题⽬：图形数据结构实验班级：软件112学号：姓名：图形数据结构实验报告要求1⽬的与要求:1）掌握图的邻接矩阵、邻接表、⼗字链表、邻接多重链表存储结构表⽰及其创建算法的c 语⾔实现；2）掌握图的深度优先搜索遍历算法和图的⼴度优先搜索遍历算法及C语⾔实现（预习）；3）按照实验题⽬要求独⽴正确地完成实验内容（提交程序清单及相关实验数据与运⾏结果）；4）认真书写实验报告,并按时提交（第12周周⼀提交）。

2 实验内容或题⽬题⽬：⼀、图形数据结构实验——图的建⽴与遍历。

内容：1）使⽤邻接矩阵和邻接表储表⽰分别实现如下给定的图1和或图2所⽰图的物理存储结构。

2）在1）所建⽴的图形存储结构上分别实现深度优先搜索遍历和⼴度优先搜索遍历，并给出遍历结果（序列）。

例2 有向图3 实验步骤与源程序#include#include#include#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define NULL 0#define MAX_VErR_NUM 10#define QueueSize 30/*邻接矩阵存储表⽰定义*/typedef enum{False,True}Boolean;Boolean visited[MAX_VErR_NUM ];typedef char VertexType;typedef int EdgeType;typedef struct{VertexType vexs[MAX_VErR_NUM ]; //顶点表EdgeType arcs[MAX_VErR_NUM ][MAX_VErR_NUM ]; //邻接矩阵,可看做边表int n,e; //图中当前的顶点数和边数}MGraph;/*邻接表定义*/typedef struct Node{int elem;struct Node *next;}Node,*QNode;typedef struct{QNode front;QNode rear;}Queue;typedef struct ArcNode /*头节点*/{int adjvex; /*该边所指向的顶点的位置*/struct ArcNode *nextarc; /*指向下⼀条边*/}ArcNode;typedef struct VNode /*表节点*/{int data; /*顶点信息*/ArcNode *firstarc; /*指向第⼀条依附该节点的边的指针*/ }VNode,AdjList[MAX_VErR_NUM ]; typedef struct{AdjList vertices; /*表节点*/int vexnum; /*节点的个数*/int arcnum; /*边的条数*/}Graph;int Visited[MAX_VErR_NUM ];/* 邻接矩阵的存储*/void CreateMGraph(MGraph *G){int i,j,k;VertexType ch1,ch2;printf("输⼊顶点数和边数:\n");fflush(stdin);scanf("%d,%d",&(G->n),&(G->e));printf("输⼊顶点号:\n");for(i=0;in;i++){getchar();scanf("%c",&(G->vexs[i]));}for(i=0;in;i++)for(j=0;jn;j++)G->arcs[i][j]=0;printf("请输⼊每条边对应的两个顶点的序号:\n"); for(k=0;ke;k++){printf("请输⼊第%d条边的顶点序号：",k+1); fflush(stdin);scanf("%c,%c",&ch1,&ch2);for(i=0;ch1!=G->vexs[i];i++);for(j=0;ch2!=G->vexs[j];j++);G->arcs[i][j]=1;}}/*邻接矩阵的深度优先遍历搜索*/void DFSM(MGraph *G,int i){int j;printf("v%c ",G->vexs[i]);visited[i]=True;for(j=0;jn;j++) //依次搜索vi邻接点if(G->arcs[i][j]==1 && !visited[j])DFSM(G,j);}void DFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=False;for(i=0;in;i++)if(!visited[i])DFSM(G,i);}/* 邻接矩阵的⼴度优先遍历搜索*/ typedef struct {int front;int rear;int count;int data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q){Q->front=Q->rear=0;Q->count=0;}int QueueEmpty(CirQueue *Q){return Q->count=QueueSize;}int QueueFull(CirQueue *Q){return Q->count==QueueSize;}void EnQueue(CirQueue *Q,int x){if (QueueFull(Q))printf("Queue overflow");else{Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize; }}int DeQueue(CirQueue *Q){int temp;if(QueueEmpty(Q)){printf("Queue underflow");return NULL;}else{temp=Q->data[Q->front];Q->count--;Q->front=(Q->front+1)%QueueSize; return temp; }}void BFSM(MGraph *G,int k){int i,j;CirQueue Q;InitQueue(&Q);printf("v%c ",G->vexs[k]);visited[k]=True;EnQueue(&Q,k);while (!QueueEmpty(&Q)){i=DeQueue(&Q);for (j=0;jn;j++)if(G->arcs[i][j]==1&&!visited[j]){printf("⼴度优先遍历结点:%c\n",G->vexs[j]); visited[j]=True; EnQueue(&Q,j);}}}void BFSTraverseM(MGraph *G){int i;for (i=0;in;i++)visited[i]=False;for (i=0;in;i++)if (!visited[i])BFSM(G,i);}/*邻接表*/void InitQueue(Queue *Q) /*初始化操作*/{Q->front=Q->rear=(QNode)malloc(sizeof(Node));if(!Q->front) exit(OVERFLOW);Q->front->next=NULL;}void EnQueue(Queue *Q,int e) /*进队操作*/{QNode p=(QNode)malloc(sizeof(Node));if(!p) exit(OVERFLOW);p->elem=e;p->next=NULL;Q->rear->next=p;Q->rear=p;}void DeQueue(Queue *Q,int *e) /*出队操作*/{QNode p;p=Q->front->next;Q->front->next=p->next;if(Q->rear==p)Q->rear=Q->front;*e=p->elem;free(p);}int QueueEmpty(Queue Q){if(Q.rear==Q.front) return TRUE;else return -1;}int LocateVex(Graph *G,int v) /*返回节点v在图中的位置*/ {int i; for(i=0;ivexnum;++i)if(G->vertices[i].data==v) break;else continue;if(ivexnum) return i;else return 0;}/*邻接表创建*/void CreateGraph(Graph *G){int m,n,i,j,k,v1,v2,flag=0;ArcNode *p1,*q1,*p,*q;printf("请输⼊有向图的顶点和边数⽬: ");scanf("%d,%d",&m,&n);G->vexnum=m; /*顶点数⽬*/G->arcnum=n; /*边的数⽬*/for(i=0;ivexnum;++i){G->vertices[i].data=i+1; /*顶点信息*/G->vertices[i].firstarc=NULL;}for(k=0;karcnum;++k){printf("请输⼊第 %d 条边的起点和终点: ",k+1);scanf("%d,%d",&v1,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);if(i>=0&&j>=0){++flag;p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=NULL;if(!G->vertices[i].firstarc) G->vertices[i].firstarc=p;else{for(p1=G->vertices[i].firstarc;p1->nextarc;p1=p1->nextarc); p1->nextarc=p;}q=(ArcNode *)malloc(sizeof(ArcNode));q->adjvex=i;q->nextarc=NULL;if(!G->vertices[j].firstarc) G->vertices[j].firstarc=q;else{for(q1=G->vertices[j].firstarc;q1->nextarc;q1=q1->nextarc);q1->nextarc=q;}}else{printf("Not hava this edge!\n");k=flag;}}}int FirstAdjVex(Graph G,int v)/*返回v的第⼀个邻接顶点*/{if(G.vertices[v].firstarc)return G.vertices[v].firstarc->adjvex;elsereturn -1;}int NextAdjVex(Graph G,int v,int w)/*返回v中相对于w的下⼀个邻接顶点*/ {int flag=0; ArcNode *p;p=G.vertices[v].firstarc;while(p){if(p->adjvex==w){flag=1;break;}p=p->nextarc;}if(flag && p->nextarc)return p->nextarc->adjvex;elsereturn -1;}/*邻接表深度优先遍历*/void DFS(Graph G,int v){int w;Visited[v]=TRUE;printf("v%d ",G.vertices[v].data);for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)) if(!Visited[w]) DFS(G,w);}void DFSTraverse(Graph G){int v;for(v=0;vVisited[v]=FALSE;for(v=0;vif(!Visited[v]) DFS(G,v);}/*邻接表⼴度优先遍历*/void BFSTraverse(Graph G)/*⼴度优先遍历*/{int v,v1,w;Queue q;for(v=0;vVisited[v]=FALSE;InitQueue(&q);for(v=0;vif(!Visited[v]){Visited[v]=TRUE;printf("v%d ",G.vertices[v].data);EnQueue(&q,v); /*第⼀个顶点⼊队*/while(!QueueEmpty(q)){DeQueue(&q,&v1); /*第⼀个顶点出对*/for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,w))if(!Visited[w]){Visited[w]=TRUE;printf("v%d ",G.vertices[w].data);EnQueue(&q,w);}}}}void main(){int a,flag=1;MGraph G;Graph g;printf("1 对邻接矩阵进⾏深度优先遍历与⼴度优先遍历 \n2 对邻接表进⾏深度优先遍历与⼴度优先遍历 \n3 退出 \n"); while(flag){printf("请选择：");scanf("%d",&a);switch(a){case 1:CreateMGraph(&G);printf("深度优先遍历结点: ");DFSTraverseM(&G);printf("\n");printf("⼴度优先遍历结点:");BFSTraverseM(&G);printf("\n");break;case 2:CreateGraph(&g);printf("深度优先搜索为:\n");DFSTraverse(g);printf("\n");printf("⼴度优先搜索为:\n");BFSTraverse(g);printf("\n");break;case 3:flag=0;break;}}}4 测试数据与实验结果（可以抓图粘贴）5 结果分析与实验体会图的这⼀章编程很长，⽽且⽐较复杂，运⽤到前⾯很多知识，要求综合能⼒较强。

数据结构实验报告

数据结构实验报告摘要：本实验是针对数据结构概念与应用的课程要求进行的，主要目的是通过实践掌握各种数据结构的基本操作和应用场景。

在实验中，我们学习了线性表、栈、队列、二叉树等数据结构，并实现了它们的各种操作。

通过实验，我们深入理解了数据结构的原理和应用，并且掌握了如何在实际项目中应用各种数据结构来解决问题。

1. 引言数据结构是计算机科学中的一个重要概念，它研究如何组织和存储数据以及如何在这些数据上进行操作。

它对于算法的设计和优化起着至关重要的作用。

本次实验旨在通过实践，加深对数据结构的理解，并掌握其基本操作和应用场景。

2. 实验目的本实验的主要目的是：(1) 理解线性表、栈、队列和二叉树等数据结构的概念和特点；(2) 掌握各种数据结构的基本操作，如插入、删除、查找等；(3) 学会在实际项目中应用各种数据结构，解决实际问题。

3. 实验工具本实验使用的工具有：(1) 编程语言：C++；(2) 集成开发环境：Visual Studio；(3) 相关库：标准模板库(STL)。

4. 实验内容和步骤4.1 线性表线性表是最基本的数据结构之一，它包括顺序表和链表两种形式。

在本实验中，我们实现了一个基于顺序表的线性表。

具体步骤如下：(1) 定义线性表的数据结构和基本操作函数；(2) 实现线性表的初始化、插入、删除、查找、修改等基本操作；(3) 编写测试代码，验证线性表的功能和正确性。

4.2 栈栈是一种特殊的线性表，它遵循先进后出(LIFO)的原则。

在本实验中，我们实现了一个基于数组的栈。

具体步骤如下：(1) 定义栈的数据结构和基本操作函数；(2) 实现栈的初始化、入栈、出栈、查看栈顶元素等基本操作；(3) 编写测试代码，验证栈的功能和正确性。

4.3 队列队列是另一种特殊的线性表，它遵循先进先出(FIFO)的原则。

在本实验中，我们实现了一个基于链表的队列。

具体步骤如下：(1) 定义队列的数据结构和基本操作函数；(2) 实现队列的初始化、入队、出队、查看队首元素等基本操作；(3) 编写测试代码，验证队列的功能和正确性。

数据结构课程实验报告

数据结构课程实验报告目录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. 实验总结通过本次实验，学生将对数据结构与算法设计有更深入的了解，并能将所学知识应用到实际问题中，提高自己的实践能力和解决问题的能力。

树型数据结构实验

淮海工学院计算机科学系实验报告书课程名：《数据结构》题目：树型数据结构试验班级：软件082学号：110831205姓名：徐洪卫树结构算法实现与应用报告要求1目的与要求:1）熟练掌握二叉树的二叉链表表示及前序创建算法与实现；2）熟练掌握二叉树的前序、中序和后序递归遍历算法与实现；3）掌握中序遍历线索二叉树的基本算法与实现4）掌握中序遍历线索化二叉树的算法与实现；5）按照实验题目要求独立完成实验内容（提交程序清单及相关实验数据与运行结果）；6）认真书写实验报告,并按时提交。

2 实验内容或题目实验内容:1）按照先序序列建立下图所示二叉树的二插链表树，结点元素类型取字符型，树的字符序列从键盘逐个动态输入。

2）在第1）步建立好的二叉链表树上实施前序、中序和后序递归遍历，并输出相应遍历序列。

3) 在第1) 步建立好的二叉链表树上实施前序遍历的叶子结点输出。

4) 在第1) 步建立好的二叉链表树上实施前序遍历的非叶子结点输出。

5）中序线索化第1）步所建立的二叉链表树(选做)。

6）中序遍历第5）步所建立的线索二叉树，并输出遍历结果(选做)ABC DE FG3 实验步骤与源程序#include <stdio.h>#include <malloc.h>#include <conio.h>typedef char DataType;typedef struct Node{DataType data;struct Node *LChild;struct Node *RChild;}BiTNode, *BiTree;void CreateBiTree(BiTree *bt){char ch;ch = getchar();if(ch=='.') *bt=NULL;else{*bt=(BiTree)malloc(sizeof(BiTNode)); //生成一个新结点 (*bt)->data=ch;CreateBiTree(&((*bt)->LChild)); //生成左子树CreateBiTree(&((*bt)->RChild)); //生成右子树}}void Visit(char ch){printf("%c ",ch);}void PreOrder(BiTree root)/*先序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/ {if (root!=NULL){Visit(root ->data); /*访问根结点*/PreOrder(root ->LChild); /*先序遍历左子树*/PreOrder(root ->RChild); /*先序遍历右子树*/}}void InOrder(BiTree root)/*中序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/ {if (root!=NULL){InOrder(root ->LChild); /*中序遍历左子树*/Visit(root ->data); /*访问根结点*/InOrder(root ->RChild); /*中序遍历右子树*/}}void PostOrder(BiTree root)/* 后序遍历二叉树，root为指向二叉树(或某一子树)根结点的指针*/ {if(root!=NULL){PostOrder(root ->LChild); /*后序遍历左子树*/PostOrder(root ->RChild); /*后序遍历右子树*/Visit(root ->data); /*访问根结点*/}}void PreOrderleaf(BiTree root){if(root!=NULL)if(root->LChild==NULL&&root ->RChild==NULL) printf("%c",root ->data);PreOrderleaf(root ->LChild); PreOrderleaf(root ->RChild);}}void UNPreOrderleaf(BiTree root){if(root!=NULL){if(root->LChild!=NULL||root ->RChild!=NULL) printf("%c",root ->data);UNPreOrderleaf(root ->LChild); UNPreOrderleaf(root ->RChild);}}void main(){BiTree T;int n;printf("**先序遍历序列创建二插树:**\n"); printf("请输入遍历序列('.'代表空子树):\n");CreateBiTree(&T);found: printf("请选择您要进行的操作:\n"); printf(" ****************************\n"); printf(" *1:先序遍历序列 *\n");printf(" *2:中序遍历序列 *\n"); printf(" *3:后续遍历序列 *\n"); printf(" *4:前序遍历的叶子结点输出 *\n"); printf(" *5:前序遍历的非叶子结点输出*\n"); printf(" ****************************\n"); scanf("%d",&n);switch(n){case 1:printf("先序遍历序列为:");PreOrder(T);printf("\n");printf("0.退出界面，1.返回原界面"); printf("\n");scanf("%d",&n);if(n==1)goto found;case 2:printf("\n中序遍历序列为:");InOrder(T);printf("\n");printf("0.退出界面，1.返回原界面"); printf("\n");scanf("%d",&n);if(n==1)goto found;break;case 3:printf("\n后序遍历序列为:");PostOrder(T);printf("\n");printf("0.退出界面，1.返回原界面"); printf("\n");scanf("%d",&n);if(n==1)goto found;break;case 4:PreOrderleaf(T);printf("\n");printf("0.退出界面，1.返回原界面\n");scanf("%d",&n);if(n==1)goto found;break;case 5:UNPreOrderleaf(T);printf("\n");printf("0.退出界面，1.返回原界面\n");scanf("%d",&n);if(n==1)goto found;break;}};}4 测试数据与实验结果（可以抓图粘贴）先序遍历序列创建二插树:1:先序遍历序列：2．后序遍历序列为:3.后续遍历序列：4.前序遍历的叶子结点输出：5.前序遍历的叶子结点输出：5 结果分析与实验体会这个实验，自己一共做了两次，丢了一次，得重做，挺麻烦，不过，还好，正是因为做了一次，第二次就简单多了，利用课余的时间就把它解决了。

数据结构实验报告及心得体会

数据结构实验报告及心得体会一、实验背景和目的本次实验的目的是通过设计和实现常见的数据结构，来加深对数据结构的理解，并能够熟练运用。

实验中使用的数据结构有栈、队列和链表，通过这些数据结构的设计和应用，能够更好地掌握数据结构的原理和应用。

二、实验过程1. 栈的设计和实现在本次实验中，我设计了一个基于数组的栈，用于存储数据。

首先，我定义了一个栈类，包含栈的容量、栈顶指针和存储数据的数组。

然后，我实现了入栈、出栈和判断栈空、栈满的操作。

在测试阶段，我编写了一些测试用例，验证栈的功能和正确性。

2. 队列的设计和实现在本次实验中，我设计了一个基于链表的队列。

首先，我定义了一个队列类，包含队列的头指针和尾指针。

然后，我实现了入队、出队和判断队列空、队列满的操作。

在测试阶段，我编写了一些测试用例，验证队列的功能和正确性。

3. 链表的设计和实现在本次实验中，我设计了一个能够存储任意数据类型的单链表。

首先，我定义了一个链表类，包含链表的头指针和尾指针。

然后，我实现了插入、删除和查找节点的操作。

在测试阶段，我编写了一些测试用例，验证链表的功能和正确性。

三、实验结果和分析通过本次实验，我成功设计和实现了栈、队列和链表这三种常见的数据结构。

在测试阶段，我对这些数据结构进行了充分的测试，验证了它们的功能和正确性。

在测试过程中，我发现栈和队列在实际应用中具有很大的作用。

例如，在计算表达式的过程中，可以利用栈来实现中缀表达式转后缀表达式的功能；在操作系统中，可以利用队列来实现进程的调度。

此外，在实验过程中，我还进一步加深了对数据结构的理解。

通过设计和实现数据结构，我学会了如何根据问题的需求选择合适的数据结构，并能够运用数据结构解决实际问题。

在实现过程中，我遇到了一些问题，例如链表的插入和删除操作需要考虑前后指针的变化，但通过不断的实践和思考，最终成功解决了这些问题。

同时，我还注意到数据结构的时间复杂度和空间复杂度对算法的性能有着重要的影响，因此在设计数据结构时需要充分考虑这些因素。

图状数据结构实验

Graphicmap[i].id =0;
Graphicmap[i].link =NULL;
}
printf("某项目的开始到结束在图中的节点输入<vi,vj,dut>\n");
printf("如：3,4,9 回车表示第三节点到第四节点之间的活动用了9个单位时间\n");
for(k=0;k<activenumber;k++)
while(p)
{
k=p->adjvex ;
Graphicmap[k].id --;
if(ve[j]+p->dut >ve[k])
ve[k]=ve[j]+p->dut ;
if(Graphicmap[k].id ==0)
topologystack[++rear]=k;
p=p->next ;
}
}
if(m<projectnumber)
for(i=0;i<projectnumber;i++)
{
if(Graphicmap[i].id==0)
{
topologystack[++rear]=i;
m++;
}
}
while(front!=rear)
{
front++;
j=topologystack[front];
m++;
p=Graphicmap[j].link ;
for(j=0;j<projectnumber;j++)
{
p=Graphicmap[j].link;