南航专接本《数据结构》实验报告3
数据结构实验报告实验总结
数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。
通过实验，我对这些数据结构的特点、操作和应用有了更深入的了解。
下面对每一部分实验进行总结。
实验一：线性表的基本操作线性表是一种常见的数据结构，本实验要求实现线性表的基本操作，包括插入、删除、查找、遍历等。
在实验过程中，我对线性表的结构和实现方式有了更清晰的认识，掌握了用数组和链表两种方式实现线性表的方法。
实验二：栈的应用栈是一种后进先出（LIFO）的数据结构，本实验要求利用栈实现简单的括号匹配和后缀表达式计算。
通过实验，我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算，有效地解决了对应的问题。
实验三：队列的应用队列是一种先进先出（FIFO）的数据结构，本实验要求利用队列实现银行排队和迷宫求解。
通过实验，我对队列的应用有了更加深入的了解，了解到队列可以解决需要按顺序处理的问题，如排队和迷宫求解等。
实验四：链表的应用链表是一种常用的数据结构，本实验要求利用链表实现学生信息管理系统。
通过实验，我对链表的应用有了更深入的了解，了解到链表可以方便地实现对于数据的插入、删除和修改等操作，并且可以动态地调整链表的长度，适应不同的需求。
通过本次实验，我掌握了线性表、栈、队列和链表的基本操作，并了解了它们的特点和应用方式。
同时，通过实际编程的过程，我对于数据结构的实现方式和效果有了更直观的认识，也锻炼了自己的编程能力和解决问题的能力。
在实验过程中，我遇到了一些问题，如程序逻辑错误和内存泄漏等，但通过调试和修改，最终成功解决了这些问题，对自己的能力也有了更多的信心。
通过本次实验，我深刻体会到了理论与实践的结合的重要性，也对于数据结构这门课程有了更加深入的理解。
总之，本次数据结构实验给予了我很多有益的启发和收获，对于数据结构的概念、特点和应用有了更深入的理解。
在以后的学习中，我会继续加强对数据结构的学习和研究，不断提高自己的编程能力和解决问题的能力。
《数据结构》实验报告3
实验三——图一、实验目的1.掌握图的基本概念；2.掌握图的存储结构及其建立算法；3.熟练掌握图的两种遍历算法及其应用。
二、实验内容1.对给定的图G，设计算法输出从V0出发深（广）度遍历图G的深（广）度优先搜索序列；2.设计算法输出给定图G的连通分量个数及边（或弧）的数目。
三、实验预习内容在实验中要用到这几个函数：typedef struct 邻接矩阵的创建，Locate函数去查找，create 函数创建图，定义两个指针firstadj,nextadj找寻临接点和下一个临接点，void dfs函数从某一点开始遍历，void dfsgraph进行图的遍历算法，然后就是main 函数。
四、上机实验1.实验源程序。
#include<>#define max 80int num1=0,num2=0;bool visited[max]; ."<<"\n\ number of bian"<<endl;cout<<"Please choose:";cin>>choice;switch(choice){case 1:creat(G);break;case 2:{dfsgraph(G);cout<<endl;};break;case 3:cout<<num1<<endl;break;case 4:cout<<num2/2<<endl;break;}cout<<"Continue(Y/N):";cin>>ctinue;if(ctinue=='Y'||ctinue=='y')flag=1;else flag=0;}}2.实验结果（截图）。
开始界面：创建函数界面：输出创建的函数：输出创建函数的连通分量：输出创建函数的边数：五、实验总结（实验过程中出现的问题、解决方法、结果或其它）在这两个实验中，对locate 函数的编写存在问题，不知道自己怎么去定位，函数该怎么样编写后来用这样编写就可以了。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构，由结点和边组成。
树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中，我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树，每个结点最多只有两个子结点。
根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。
然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。
如果当前结点为空，则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。
如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。
- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。
- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。
数据结构实验报告3
数据结构实验报告3数据结构实验报告3引言：数据结构是计算机科学中的一个重要概念，它涉及到数据的组织、存储和管理。
在本次实验中，我们将探索一些常见的数据结构，并通过实验来验证它们的性能和效果。
一、线性表线性表是最基本的数据结构之一，它是一种由一组数据元素组成的有序序列。
在本次实验中，我们使用了顺序表和链表来实现线性表。
顺序表是一种连续存储的数据结构，它可以通过下标来访问元素。
我们通过实验比较了顺序表的插入和删除操作的时间复杂度，发现在插入和删除元素较多的情况下，顺序表的性能较差。
链表是一种非连续存储的数据结构，它通过指针来连接各个元素。
我们通过实验比较了链表的插入和删除操作的时间复杂度，发现链表在插入和删除元素时具有较好的性能。
二、栈栈是一种特殊的线性表，它只允许在表的一端进行插入和删除操作。
在本次实验中，我们实现了栈的顺序存储和链式存储两种方式。
顺序存储的栈使用数组来存储元素，我们通过实验比较了顺序存储栈和链式存储栈的性能差异。
结果表明，在元素数量较少的情况下，顺序存储栈具有较好的性能，而在元素数量较多时，链式存储栈更具优势。
三、队列队列是一种特殊的线性表，它只允许在表的一端进行插入操作，在另一端进行删除操作。
在本次实验中，我们实现了队列的顺序存储和链式存储两种方式。
顺序存储的队列使用数组来存储元素，我们通过实验比较了顺序存储队列和链式存储队列的性能差异。
结果表明，顺序存储队列在插入和删除元素时具有较好的性能，而链式存储队列在元素数量较多时更具优势。
四、树树是一种非线性的数据结构，它由一组称为节点的元素组成，通过节点之间的连接来表示数据之间的层次关系。
在本次实验中，我们实现了二叉树和二叉搜索树。
二叉树是一种每个节点最多有两个子节点的树结构，我们通过实验验证了二叉树的遍历算法的正确性。
二叉搜索树是一种特殊的二叉树，它的左子树的所有节点都小于根节点，右子树的所有节点都大于根节点。
我们通过实验比较了二叉搜索树的插入和查找操作的时间复杂度，发现二叉搜索树在查找元素时具有较好的性能。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程，通过本次实验，旨在加深对常见数据结构（如链表、栈、队列、树、图等）的理解和应用，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为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 。
南京航空航天大学软件技术基础数据结构上机实验报告
南京航空航天大学计算机软件技术基础实践实验报告课程名称：计算机软件技术基础专题：数据结构上机实践姓名：xxx学号：xxx学院：自动化学院专业：自动化班级：xxx2013年10月目录（程序和流程图）实验一------------------------------------4第一种算法---------------------------4第二种算法---------------------------7实验二------------------------------------9线性表------------------------------9单链表------------------------------11顺序栈------------------------------14链栈---------------------------------15链列---------------------------------18实验三------------------------------------20二叉树----------------------------20实验四------------------------------------22顺序查找------------------------22二分查找------------------------24插入排序------------------------26选择排序------------------------28冒泡排序------------------------30大作业------------------------------------32通讯录---------------------------32一、实验一实验对象：顺序表。
实验目的：实现两个顺序表的合并。
实验要求：将共同拥有的元素只存其一。
思路清晰，编程正确，并将数据元素显示出来。
数据结构实验报告及心得体会
数据结构实验报告及心得体会一、概述：介绍本次实验的目的、背景以及所使用的实验环境和工具。
本次实验旨在通过实际操作，深入理解和掌握数据结构的原理及应用。
实验背景源于课程学习的理论知识与实际应用相结合的需求，通过实验操作，期望能够将课堂所学的数据结构知识更好地运用到实际编程和解决现实问题中。
本次实验所使用的实验环境为先进的计算机实验室，配备了高性能的计算机硬件和丰富的软件开发工具。
为了完成实验，我使用了Java编程语言，并结合Eclipse开发环境进行编程和调试。
我还参考了相关的数据结构专业书籍和在线资源，以便更好地理解和应用数据结构知识。
在实验过程中，我严格按照实验指导书的步骤进行操作，并认真记录了实验数据和结果。
通过本次实验，我深刻体会到了数据结构的重要性，也对数据结构的实现和应用有了更深入的了解。
二、实验内容：分别介绍线性数据结构（线性表）、非线性数据结构（二叉树、图）的实验内容，包括其实现方法、操作过程等。
每个实验都包含具体的实验目的和预期结果。
三、实验过程及结果分析：详细描述实验过程，包括实验步骤的执行情况，遇到的问题及解决方法。
对实验结果进行展示，并进行数据分析和结论。
这部分是实验报告的核心部分，体现了学生的实践能力和问题解决能力。
四、心得体会：分享在实验过程中的心得体会，包括遇到的困难、收获，对数据结构的理解与认识提升，以及实验过程中的团队协作和学习体验等。
这部分内容可以体现出学生的思考深度和学习的主观感受。
五、总结与展望：对本次实验报告进行总结，并对未来数据结构与算法的学习提出展望和建议。
这部分内容可以帮助学生梳理所学知识，明确未来的学习方向。
《数据结构》实训报告
《数据结构》实训报告数据结构实训报告一、实训目的和意义数据结构是计算机科学与技术专业的一门重要基础课程，通过学习数据结构可以帮助我们提高程序的效率和优化算法的性能。
在这次实训中，我们旨在通过实践应用所学的数据结构知识，进行问题解决和算法设计，提高我们的编程能力和思维逻辑。
二、实训内容和过程本次实训主要包括以下几个部分：线性表的应用、栈和队列的实现、树和图的应用。
首先，我们针对线性表的应用，选择了用数组实现一个顺序表和用链表实现一个单链表。
通过实际编程和调试，我们深入了解了数组和链表的特性和功能，并对其进行了性能对比和分析。
顺序表适合查找操作，但插入和删除操作的效率较低；而链表则可以实现快速插入和删除操作，但查找效率相对较低。
接着，我们实现了栈和队列这两种常用的数据结构。
我们分别使用数组和链表实现了栈和队列，并进行了相关操作的测试。
通过实际运行和验证，我们了解到栈和队列的应用场景和特点。
栈适用于递归和表达式求值等场景，而队列则适用于模拟等先进先出的场景。
最后，我们进行了树和图的应用。
我们实现了一个二叉树，并对其进行了遍历的操作。
此外，我们使用邻接矩阵实现了一个有向图，并进行了深度优先和广度优先的操作。
通过实践，我们加深了对树和图结构的理解，以及相关算法的应用和分析。
三、实践总结和收获通过这次数据结构的实训，我们学到了很多理论知识的应用和实践技巧。
具体来说，我们深入了解了线性表、栈、队列、树和图等数据结构的基本概念、特性和实现方式。
同时，我们掌握了相应的算法设计和优化的方法。
在实践过程中，我们遇到了不少问题和困难。
例如，在实现链表时，我们经常会出现指针指向错误或者内存泄漏的情况。
但通过调试和修改，我们逐渐克服了这些问题，并成功完成了实践任务。
通过这次实训，我们不仅提高了编程实践的能力，更重要的是加深了对数据结构的理解和应用。
我们了解了不同数据结构之间的特点和适用场景，能够根据实际问题选择合适的数据结构和算法。
数据结构实验实训报告单
一、实验名称：数据结构实验实训二、实验时间：2023年10月25日三、实验地点：计算机实验室四、实验目的：1. 理解并掌握数据结构的基本概念和常用算法；2. 学会使用C++语言实现数据结构的操作；3. 提高编程能力和问题解决能力；4. 加深对数据结构在实际应用中的理解。
五、实验内容：1. 实验一：线性表（1）实验内容：实现线性表的基本操作，如插入、删除、查找、排序等。
（2）实验步骤：a. 定义线性表的数据结构；b. 实现线性表的插入、删除、查找、排序等操作；c. 编写测试程序，验证实验结果。
2. 实验二：栈与队列（1）实验内容：实现栈和队列的基本操作，并分析其时间复杂度和空间复杂度。
（2）实验步骤：a. 定义栈和队列的数据结构；b. 实现栈和队列的入栈、出栈、入队、出队等操作；c. 分析栈和队列的时间复杂度和空间复杂度；d. 编写测试程序，验证实验结果。
3. 实验三：链表（1）实验内容：实现链表的基本操作，如插入、删除、查找、排序等。
（2）实验步骤：a. 定义链表的数据结构；b. 实现链表的插入、删除、查找、排序等操作；c. 编写测试程序，验证实验结果。
4. 实验四：树与二叉树（1）实验内容：实现二叉树的基本操作，如插入、删除、查找、遍历等。
（2）实验步骤：a. 定义二叉树的数据结构；b. 实现二叉树的插入、删除、查找、遍历等操作；c. 编写测试程序，验证实验结果。
5. 实验五：图（1）实验内容：实现图的基本操作，如图的创建、添加边、查找路径等。
（2）实验步骤：a. 定义图的数据结构；b. 实现图的创建、添加边、查找路径等操作；c. 编写测试程序，验证实验结果。
六、实验心得：1. 通过本次实验，我对数据结构的基本概念和常用算法有了更深入的理解，为今后的学习和工作打下了坚实的基础。
2. 在实验过程中，我学会了使用C++语言实现数据结构的操作，提高了自己的编程能力。
3. 通过对数据结构在实际应用中的分析，我认识到数据结构在计算机科学中的重要地位，为今后的职业发展指明了方向。
《数据结构》实训报告
实验一线性表1.实验要求1.1掌握数据结构中线性表的基本概念。
1.2熟练掌握线性表的基本操作：创建、插入、删除、查找、输出、求长度及合并并运算在顺序存储结构上的实验。
1.3熟练掌握链表的各种操作和应用。
2.实验内容2.1编写一个函数，从一个给定的顺序表A中删除元素值在x到y之间的所有元素，要求以较高效率来实现。
2.2试写一个算法，在无头结点的动态单链表上实现线性表插入操作2.3设计一个统计选票的算法，输出每个候选人的得票结果。
3.实验代码2.1代码：#include<stdio.h>typedef int elemtype;#define maxsize 10int del(int A[],int n,elemtype x,elemtype y){int i=0,k=0;while(i<n){if(A[i]>=x&&A[i]<=y)k++;elseA[i-k]=A[i];i++;}return(n-k);}void main(){int i,j;int a[maxsize];printf("输入%d个数:\n",maxsize);for(i=0;i<maxsize;i++)scanf("%d,",&a[i]);——j=del(a,maxsize,1,3);printf("输出删除后剩下的数:\n");for(i=0;i<j;i++)printf("%d "\n,a[i]);}2.2代码：INSERT(L,i,b)。
void Insert(Linklist &L,int i,elemtype x){if(!L){L=(Linklist)malloc(sizeof(Lnode));(*L).data=x;(*L).next=NULL;}else{if(i==1){s=(Linklist)malloc(sizeof(Lnode));s->data=x;s->next=L;L=s;}else{p=L;j=1;while(p&&j<i-1){j++;p=p->next;}if(p||j>i-1)return error;s=(Linklist)malloc(sizeof(Lnode));s->data=x;s->next=p->next;p->next=s;}}}2.3代码：typedef int elemtypetypedef struct linknode{elemtype data;struct linknode *next;}nodetype;——nodetype *create(){elemtype d;nodetype h=NULL,*s,*t;int i=1;printf("建立单链表:\n");while(1){printf("输入第%d个结点数据域",i);scanf("%d",&d);if(d==0)break;if(i==1){h=(nodetype *)malloc(sizeof(nodetype));h->data=d;h->next=NULL;t=h;}else{s=(nodetype *)malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;}i++;}return h;}void sat(nodetype *h,int a[]){nodetype *p=h;while(p!=NULL){a[p->data]++;p=p->next;}}void main(){int a[N+1],i;for(i=0;i<N;i++)a[i]=0;nodetype *head;head=create();sat(head,a);——printf("候选人:");for(i=1;i<=N;i++) printf("%3d",i);printf("\n得票数\n");for(i=1;i<=N;i++)printf("%3d",a[i]);printf("\n");}4.实验小结线性表是最简单的、最常用的一种数据结构，是实现其他数据结构的基础。
数据结构实验报告
数据结构实验报告摘要：本实验是针对数据结构概念与应用的课程要求进行的，主要目的是通过实践掌握各种数据结构的基本操作和应用场景。
在实验中，我们学习了线性表、栈、队列、二叉树等数据结构，并实现了它们的各种操作。
通过实验，我们深入理解了数据结构的原理和应用，并且掌握了如何在实际项目中应用各种数据结构来解决问题。
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 操作系统：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 许可协议：指允许他人在一定条件下使用自己的知识产权的协议。
数据结构实验报告
【问题描述】
假设表达式中允许有两种括号：圆括号和方括号，其嵌套的顺序随意，即（（）[ ]）或[（[ ] [ ]）]等为正确格式，[（]）或（（（]均为不正确的格式。读入含圆括号和方括号的符号序列，输出“匹配”或“此串括号匹配不合法”。
【测试数据】
输入（[ ]（）），结果“匹配”
原理：运用栈的后进先出的特性。
算法描述：
void check(){
SqStack s;
SElemType *p,e;
char ch[80];
InitStack(s);
printf("请输入带括号（()和{}）的表达式\n");
gets(ch);
p = ch;
while(*p)
switch(*p){
case'(':
若采用链式存储结构，首先设立三个指针pa，pb，pc，其中pa,pb分别指向La表和Lb表中当前待比较插入的结点，而pc指向Lc中的当前最后一个结点，若pa->data<=pb->data,则将pa所指结点链接到pc所指结点之后，否则将pb所指结点链接到pc所指结点之后。当一个为空时，说明有一个表的元素已归并完，则只要将另一个表的剩余段链接在pc所指结点之后即可。
int i;
for(i=0;i<=L.length-1;i++);
printf("%d ",L.elem[i]);
printf("\n");
printf("the length is:%d\n",L.length);
}
void main(){
SqList L,L1,L2;
最新数据结构实验3精品版
2020年数据结构实验3精品版《数据结构》实验报告void main(){int n,i,a;//n为节点数，i为插入元素的位置，a为插入元素的值LinkList L;printf("请输入链式表的节点数:");scanf("%d",&n);CreateList_L ( L, n ); //初始化链表节点个数为nprintf("请输入要插入的位置:");scanf("%d",&i);printf("请输入要插入的值:");scanf("%d",&a);ListInsert_L(L,i,a); //在第i个位置插入元素aShowList_L(L); //输出链表L中的所有元素}运行以上程序，根据要求完成下列题目：1.参考P30页中的例题2.10实现ListDelete_L函数，并在主函数中测试；2.编写一个函数计算值域为x的结点个数，并在主函数中测试；以下题目任选一题：3.编写一个删除链表中值为x的结点的直接前趋结点的算法，若有多个值为x的结点，则删除第一个x的直接前趋结点；4.改写CreateList_L函数，使得链表创建时为非降序排列；5.改写ListInsert_L函数，忽略位置参数，在上述非降序排列链表中插入一个元素，使得链表依然保持非降序；附源程序清单：1# include <stdlib.h># include <stdio.h># define ERROR 1# define OK 0# define OVERFLOW 1typedef int ElemType;//给int一个别名ElemType typedef int Status;//给int一个别名Status typedef struct LNode{ElemType data;struct LNode *next;} LNode, *LinkList;void CreateList_L ( LinkList &L, int n ){// 输入 n 个数据元素的值，建立带头结点的单链表 Lprintf("请输入插入链表的节点值:\n");LinkList p;int i;L = ( LinkList ) malloc ( sizeof ( LNode ) );L->next = NULL; // 先建立一个带头结点的空链表for ( i = n; i > 0; i-- ){p = ( LinkList ) malloc ( sizeof ( LNode ) );scanf ("%d" ,&p->data );p->next = L->next;L->next = p;}}Status ListInsert_L ( LinkList &L, int i, ElemType e ){// 带头结点的单链表L中第 i 个位置之前插入元素 eLinkList p,s;int j; //j为计数器p = L; //p指向L的头节点j = 0;while ( p && j<i-1 ) //顺指针向后查，直到p指向第i个元素之前{p = p->next; ++j;}if ( ! p || j >i-1 )return ERROR;s = ( LinkList ) malloc ( sizeof ( LNode ) ); // 生成新结点s->data = e; // 使新结点数据域的值为 es->next = p->next; // 将新结点插入到单链表 L 中p->next = s; // 修改第 i-1 个结点指针return OK;}void ShowList_L ( LinkList L ){// 输出链表L中的所有元素LinkList p;printf("链表中的元素为:\n");p=L->next; //跳过头结点while(p){printf(" %d ",p->data);p=p->next;}}Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p,q;int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)return ERROR;q=p->next;p->next=q->next;e=q->data; free(q);return OK;}void main(){int n,i,a,x;//n为节点数，i为插入元素的位置，a为插入元素的值LinkList L;printf("请输入链式表的节点数:");scanf("%d",&n);CreateList_L ( L, n ); //初始化链表节点个数为nprintf("请输入要插入的位置:");scanf("%d",&i);printf("请输入要插入的值:");scanf("%d",&a);ListInsert_L(L,i,a); //在第i个位置插入元素aShowList_L(L); //输出链表L中的所有元素printf("请输入要删除的位置:");scanf("%d",&x);ListDelete_L(L,x,i);ShowList_L(L);}2 # include <stdlib.h># include <stdio.h># define ERROR 1# define OK 0# define OVERFLOW 1typedef int ElemType;//给int一个别名ElemTypetypedef int Status;//给int一个别名Statustypedef struct LNode{ElemType data;struct LNode *next;} LNode, *LinkList;void CreateList_L ( LinkList &L, int n ){// 输入 n 个数据元素的值，建立带头结点的单链表 Lprintf("请输入插入链表的节点值:\n");LinkList p;int i;L = ( LinkList ) malloc ( sizeof ( LNode ) );L->next = NULL; // 先建立一个带头结点的空链表for ( i = n; i > 0; i-- ){p = ( LinkList ) malloc ( sizeof ( LNode ) );scanf ("%d" ,&p->data );p->next = L->next;L->next = p;}}Status ListInsert_L ( LinkList &L, int i, ElemType e ){// 带头结点的单链表L中第 i 个位置之前插入元素 eLinkList p,s;int j; //j为计数器p = L; //p指向L的头节点j = 0;while ( p && j<i-1 ) //顺指针向后查，直到p指向第i个元素之前{p = p->next; ++j;}if ( ! p || j >i-1 )return ERROR;s = ( LinkList ) malloc ( sizeof ( LNode ) ); // 生成新结点s->data = e; // 使新结点数据域的值为 es->next = p->next; // 将新结点插入到单链表 L 中p->next = s; // 修改第 i-1 个结点指针return OK;}void ShowList_L ( LinkList L ){// 输出链表L中的所有元素LinkList p;printf("链表中的元素为:\n");p=L->next; //跳过头结点while(p){printf(" %d ",p->data);p=p->next;}}Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p,q;int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)return ERROR;q=p->next;p->next=q->next;e=q->data; free(q);return OK;}Status Mycompara_L(LinkList &L,ElemType y ){LinkList p;int i=0;p=L->next;while(p){if(p->data==y) i++;p=p->next;}printf("链表中一共有%d个要查找的结点:\n",i);return 0;}void main(){int n,i,a;//n为节点数，i为插入元素的位置，a为插入元素的值LinkList L;ElemType x;printf("请输入链式表的节点数:");scanf("%d",&n);CreateList_L ( L, n ); //初始化链表节点个数为n printf("请输入需要查找的节点值:\n");scanf("%d",&x);Mycompara_L(L,x);}p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)return ERROR;q=p->next;p->next=q->next;e=q->data; free(q);return OK;}Status Mycompara_L(LinkList &L,ElemType y ){LinkList p;int i=0;p=L->next;while(p){if(p->data==y) i++;p=p->next;}printf("链表中一共有%d个要查找的结点:\n",i);return 0;}Status mycompara_delete(LinkList &L){LinkList p,q,s;p=L->next;while(p&&p->next){s=p;q=p->next;while (q){if(q->data==p->data){ s->next=q->next;free(q);q=s->next;}else{ s=q;q=q->next;}}p=p->next;}return 0;}void main(){int n;//n为节点数，i为插入元素的位置，a为插入元素的值LinkList L;printf("请输入链式表的节点数:");scanf("%d",&n);CreateList_L ( L, n ); //初始化链表节点个数为nmycompara_delete(L);ShowList_L(L);}。
数据结构实习报告
一、实习背景随着计算机科学技术的不断发展，数据结构作为计算机科学的重要基础，在各个领域都发挥着重要作用。
为了提高自己的实践能力，加深对数据结构理论知识的理解，我参加了本次数据结构实习。
通过实习，我学习了数据结构在实际应用中的实现方法和技巧，提高了自己的编程能力和问题解决能力。
二、实习内容1. 实习项目概述本次实习项目是一个基于C语言实现的学生信息管理系统。
系统包括学生信息的添加、删除、修改、查询等功能。
在实现过程中，我主要使用了线性表、链表、栈、队列、树等数据结构。
2. 数据结构设计（1）线性表：用于存储学生信息，包括学号、姓名、性别、年龄、班级等字段。
（2）链表：实现学生信息的添加、删除、修改等功能。
（3）栈：实现学生信息的临时存储，如删除操作时需要先弹出栈顶元素。
（4）队列：实现学生信息的排序功能，如按学号排序。
（5）树：实现学生信息的分类存储，如按班级分类。
3. 程序设计（1）主程序：负责调用各个模块，实现学生信息管理系统的整体功能。
（2）数据输入模块：负责从用户处获取输入的学生信息，并将其存储到数据结构中。
（3）数据输出模块：负责将学生信息显示给用户，包括添加、删除、修改、查询等操作的结果。
（4）数据操作模块：负责实现学生信息的各种操作，如添加、删除、修改、查询等。
三、实习成果1. 实现了一个功能完善的学生信息管理系统。
2. 掌握了线性表、链表、栈、队列、树等数据结构在实际应用中的实现方法和技巧。
3. 提高了编程能力和问题解决能力。
4. 了解了软件开发的流程，如需求分析、设计、编码、测试等。
四、实习体会1. 数据结构是计算机科学的重要基础，在实际应用中具有重要意义。
2. 在编程过程中，要善于运用各种数据结构，以提高程序的性能和可读性。
3. 需要具备良好的编程习惯，如代码规范、注释清晰等。
4. 在遇到问题时，要善于查阅资料，分析问题，提出解决方案。
5. 团队合作是软件开发的重要环节，要学会与他人沟通、协作。
数据结构实验报告三
<1>初始化一个队列。
循环队列：
链队列：
<2>判断是否队空。
循环队列：
链队列：
<3>判断是否队满。
循环队列：
第一组数据：入队n个元素，判断队满
第二组数据：用循环方式将1到99，99个元素入队，判队满
入队
第一组数据：4，7，8，12，20，50
第二组数据：a,b,c,d,f,g
出队
取队头元素
3.数据结构设计
循环队列
4.算法设计
（除书上给出的基本运算（这部分不必给出设计思想），其它实验内容要给出算法设计思想）
求当前队列中的元素个数：书写函数配合出队函数和判对空函数，定义一个整型变量i计数，在一个循环中每出对一次，计数器加一，直到对空，返回i即为队列元素个数。
第二题：首先判断队列是否队满，如果队满打印队满，结束程序，如果队列不满则进行下一步操作，定义一个变量x，从键盘输入其值，判断如果x的值为0，结束程序，如果不为0进入循环，如果x的模运算不等于0，将x入队，反之出队，直到x的模运算等于0，最后通过循环输出队列。
实现:从列不空,删除Q的队头元素用e返回其值，并返回OK,则返回ERROR
Status EnQueue (LinkQueue *Q, QE1emType e) {
QueuePtr p
if (Q->front==Q- >rear)
三、循环队列与链队列性能分析
1.循环队列与链队列基本操作时间复杂度均为0(1);
2.队列的抽象数据队列Data同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。Operation InitQueue(*Q):初始化操作,建立一个空队列Q. DestoryQueue(*Q):若队列Q存在，则销毁它。ClearQueue(*Q):将队列Q清空 GetHead(Q,*e):若队列Q存在且非空,用e返回队列Q的队头元素。EnQueue(*Q,e):若队列Q存在且非空, 插入新元素e到队列Q中并称为队元素。DeQueue(*Q,*e):删除队列Q中队头元素,并用e返回其值QueueL ength(Q)。
数据结构实验报告三
数据结构实验报告三数据结构实验报告三引言：数据结构作为计算机科学的重要基础，对于计算机程序的设计和性能优化起着至关重要的作用。
在本次实验中，我们将深入研究和实践数据结构的应用，通过实验来验证和巩固我们在课堂上所学到的知识。
一、实验目的本次实验的主要目的是通过实践操作，进一步掌握和理解数据结构的基本概念和操作。
具体来说，我们将学习并实现以下几个数据结构：栈、队列、链表和二叉树。
通过对这些数据结构的实现和应用，我们将更好地理解它们的特点和优势，并能够灵活运用于实际问题的解决中。
二、实验内容1. 栈的实现与应用栈是一种后进先出（LIFO）的数据结构，我们将学习如何使用数组和链表两种方式来实现栈，并通过实例来演示栈的应用场景，如括号匹配、表达式求值等。
2. 队列的实现与应用队列是一种先进先出（FIFO）的数据结构，我们将学习如何使用数组和链表两种方式来实现队列，并通过实例来演示队列的应用场景，如任务调度、消息传递等。
3. 链表的实现与应用链表是一种动态数据结构，相比数组具有更好的灵活性和扩展性。
我们将学习如何使用指针来实现链表，并通过实例来演示链表的应用场景，如链表的插入、删除、反转等操作。
4. 二叉树的实现与应用二叉树是一种常见的树形结构，我们将学习如何使用指针来实现二叉树，并通过实例来演示二叉树的应用场景，如二叉树的遍历、搜索等操作。
三、实验过程1. 栈的实现与应用我们首先使用数组来实现栈，并编写相关的入栈、出栈、判空、获取栈顶元素等操作。
然后，我们通过括号匹配和表达式求值两个实例来验证栈的正确性和应用性。
2. 队列的实现与应用我们使用数组来实现队列，并编写相关的入队、出队、判空、获取队头元素等操作。
然后，我们通过任务调度和消息传递两个实例来验证队列的正确性和应用性。
3. 链表的实现与应用我们使用指针来实现链表，并编写相关的插入、删除、反转等操作。
然后，我们通过链表的插入和删除操作来验证链表的正确性和应用性。
数据结构实习报告
数据结构实习报告在当今数字化的时代，数据结构作为计算机科学中的重要基石，对于高效处理和管理数据起着关键作用。
通过本次数据结构的实习，我不仅加深了对理论知识的理解，更在实践中获得了宝贵的经验和技能。
一、实习目的本次实习的主要目的是将课堂上学到的数据结构知识应用到实际的编程项目中，提高自己的编程能力和解决问题的能力。
通过实际操作，深入理解数据结构的原理和特点，掌握常见数据结构的实现和应用场景，培养良好的编程习惯和代码规范。
二、实习内容1、线性表顺序表：实现了顺序表的创建、插入、删除、查找等基本操作。
通过实际编写代码，深刻体会到顺序表在存储和访问数据时的特点，以及在插入和删除操作时可能面临的效率问题。
链表：掌握了单向链表、双向链表的实现方法。
链表在动态插入和删除元素方面具有优势，但在随机访问上相对较慢。
通过实际编程，对链表的结构和操作有了更直观的认识。
2、栈和队列栈：实现了栈的入栈、出栈操作，并应用栈解决了表达式求值等问题。
栈的后进先出特性在很多算法和程序中都有重要的应用。
队列：编写了队列的入队、出队代码，了解了队列在实现广度优先搜索等算法中的作用。
3、树二叉树：实现了二叉树的创建、遍历（前序、中序、后序）、查找、插入和删除操作。
二叉树的遍历算法是理解和应用二叉树的关键。
二叉搜索树：构建了二叉搜索树，并实现了查找、插入和删除操作。
理解了二叉搜索树在保持数据有序性方面的优势。
4、图图的表示：学习了邻接矩阵和邻接表两种图的存储方式，并实现了图的创建。
图的遍历：掌握了深度优先搜索和广度优先搜索算法，用于遍历图中的节点。
5、排序算法冒泡排序：通过多次比较和交换相邻元素，将数据有序排列。
插入排序：将待排序元素插入到已排序部分的合适位置。
选择排序：每次选择未排序部分的最小元素，与起始位置交换。
快速排序：采用分治思想，选择一个基准元素，将数据分为小于和大于基准的两部分，然后对两部分分别排序。
6、查找算法顺序查找：依次遍历数组查找目标元素。
《数据结构》南昌航空大学实验报告模板
南昌航空大学实验报告课程名称：数据结构指导老师准考证号：036811100078姓名：周文飞指导老师：廖丽实验报告内容和步骤一、实验目的：通过实践加深对数据结构的基本概念、基本理论的理解，培养学生灵活使用所学知识解决实际问题的能力，同时提高程序设计实际操作能力。
二、实验内容：实现任意大的数字（包括任意整数和任意小数）的加法，减法和乘法运算。
三、实验要求：1、本程序的数据来自文件，第一个操作数存储在“a*.txt”文件中，第二个操作数存储在“b*.txt”文件中（a*与b*分别表示两组对应的数据），这两组文件中分别存储对应的任意大数，以供程序2、本程序主要实现3个功能：任意大数的加法运算，任意大数的减法运算和任意大数的乘法运算。
大数的范围包括：任意长度的整数和任意长度的小数。
四、实验过程1.BigNumber.java[c-sharp]view plaincopyprint?1. /*自定义大数类，用数组实现任意超大整数的加减乘运算*/2. i mport java.util.Random;3. p ublic class BigNumber {4. private int[] num;5. // 无参构造函数6. public BigNumber() {7. }8. // 有参构造函数9. public BigNumber(int i) {10. num = new int[i];11. Random random = new Random();12. int j;13. for (j = 0; j < i; j++)14. num[j] = random.nextInt(10);15. // 当生成的数首位是0的话，让重新生成16. while (num[i - 1] == 0) {17. num[i - 1] = random.nextInt(10);18. }19. }20. // 加法21. public static BigNumber add(BigNumber bigA, BigNumber bigB) {22. int alen = bigA.num.length;23. int blen = bigB.num.length;24. int clen = Math.max(alen, blen);25. BigNumber result = new BigNumber();26. result.num = new int[clen];27. if (alen >= blen) {28. for (int i = 0; i < blen; i++)29. result.num[i] = bigA.num[i] + bigB.num[i];30. for (int j = blen; j < alen; j++)31. result.num[j] = bigA.num[j];32. } else {33. for (int i = 0; i < alen; i++)34. result.num[i] = bigA.num[i] + bigB.num[i];35. for (int j = alen; j < blen; j++)36. result.num[j] = bigB.num[j];37. }38. for (int k = 0; k < clen - 1; k++) {39. if (result.num[k] >= 10) {40. result.num[k] -= 10;41. result.num[k + 1]++;42. }43. }44. return result;45. }46. // 减法47. public static BigNumber subtract(BigNumber bigA, BigNumber bigB) {48. int alen = bigA.num.length;49. int blen = bigB.num.length;50. int clen = Math.max(alen, blen);51. BigNumber result = new BigNumber();52. result.num = new int[clen];53. if (alen > blen) {54. for (int i = 0; i < blen; i++)55. result.num[i] = bigA.num[i] - bigB.num[i];56. for (int j = blen; j < alen; j++)57. result.num[j] = bigA.num[j];58. } else if (alen < blen) {59. for (int i = 0; i < alen; i++)60. result.num[i] = bigB.num[i] - bigA.num[i];62. result.num[j] = bigB.num[j];63. } else {64. if (isBigger(bigA, bigB)) {65. for (int i = 0; i < clen; i++) {66. result.num[i] = bigA.num[i] - bigB.num[i];67. }68. } else {69. for (int i = 0; i < clen; i++) {70. result.num[i] = bigB.num[i] - bigA.num[i];71. }72. }73. }74. for (int k = 0; k < clen - 1; k++) {75. if (result.num[k] < 0) {76. result.num[k] += 10;77. result.num[k + 1]--;78. }79. }80. return result;81. }82. // 乘法83. public static BigNumber multiply(BigNumber bigA, BigNumber bigB) {84. int alen = bigA.num.length;85. int blen = bigB.num.length;86. int clen = alen + blen;87. int t;88. BigNumber result = new BigNumber();89. result.num = new int[clen];90. for (int i = 0; i < alen; i++) {91. BigNumber temp = new BigNumber();92. temp.num = new int[clen];93. for (int j = 0; j < blen; j++) {94. temp.num[i + j] = bigA.num[i] * bigB.num[j];95. }97. if (temp.num[k] >= 10) {98. t = temp.num[k];99. temp.num[k] = t % 10;100. temp.num[k + 1] += t / 10;101. }102. }103. result = add(result, temp);104. }105. return result;106. }107. // 判断两个位数相同的BigNumber那个大,前面的大于或者等于返回true,后面的大返回false108. public static boolean isBigger(BigNumber bigA, BigNumber bigB) { 109. boolean flag = true;110. for (int i = bigA.num.length - 1; i >= 0; i--) {111. if (bigA.num[i] < bigB.num[i]) {112. flag = false;113. break;114. }else if(bigA.num[i] > bigB.num[i]){115. break;116. }else117. continue;118. }119.120. return flag;121. }122. // 打印123. public void print() {124. if (num[num.length - 1] != 0)125. System.out.print(num[num.length - 1]);126. for (int i = num.length - 2; i >= 0; i--)127. System.out.print(num[i]);128. System.out.println();129. }130. public static void main(String[] args) { 131. // TODO Auto-generated method stub 132. BigNumber a = new BigNumber(1000); 133. System.out.println("第一个数是:"); 134. a.print();135. BigNumber b = new BigNumber(900); 136. System.out.println("第二个数是:"); 137. b.print();138. System.out.println("它们的和为:"); 139. add(a, b).print();140. System.out.println("它们的差为:"); 141. subtract(a, b).print();142. System.out.println("它们的乘积为:"); 143. multiply(a, b).print();144. }145. }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》实验报告班级：学号: 姓名：实验名称：实验三图的遍历操作实验时间：. 实验地点：指导教师：实验目的与要求：分别采用邻接矩阵和邻接表存储结构，完成图的深度优先遍历（DFS）和广度优先遍历（BFS）的操作。
搞清楚BFS算法中队列的作用。
实验内容：分别用图的邻接矩阵和邻接表的存储结构实现下列基本运算：（1）创建图；（2）深度优先遍历图；（3）广度优先遍历图。
算法设计（流程图）：算法实现程序（源代码）：（见源程序文件，附在本文后）上机调试情况（调试数据、调试过程中遇到的问题及解决方法）：由于对邻接矩阵和邻接表存储结构两个概念比较模糊，导致不会写算法，经过上网查询资料以后，对两个算法的概念以及步骤有了初步了解。
在查阅诸多算法以后，问题得以解决。
测试数据和输出结果：顶点数n和边数e：8,9顶点编号:01234567边:0,10,21,31,42,52,63,74,75,6邻接矩阵作为存储结构深度优先遍历:01374256广度优先遍历:31704256邻接链表作为存储结构深度优先遍历:02651473广度优先遍历:37140265附：源代码邻接矩阵作为存储结构#include <stdio.h>#include <stdlib.h>#define Max 100typedef struct{char vexs[Max];int edges[Max][Max];int n,e;}MGraph;void Create_MGraph(MGraph *G);void M_DFS(MGraph *G,int i);void DFS(MGraph *G);void BFS(MGraph *G,int k);void main(){MGraph *G;G=(MGraph *)malloc(sizeof(MGraph));Create_MGraph(G);printf("深度优先遍历: \t");DFS(G);printf("\n");printf("广度优先遍历: \t");BFS(G,3);}void Create_MGraph(MGraph *G){int i,j,k;char ch;printf("请输入顶点数n和边数e：以英文状态下\",\"分隔\n");scanf("%d,%d",&G->n,&G->e);printf("请输入顶点编号:\n");scanf("%c",&ch);for(i=0;i<G->n;i++){scanf("%c",&ch);G->vexs[i]=ch;}for(i=0;i<G->n;i++){for(j=0;j<G->n;j++){G->edges[i][j]=0;}}printf("输入边,创建邻接矩阵,以英文状态下\",\"分隔：\n");k=0;while(k<G->e){scanf("%d,%d",&i,&j);G->edges[i][j]=1;G->edges[j][i]=1;k++;}}typedef enum{FALSE,TRUE} Boolean; Boolean visited[Max];void M_DFS(MGraph *G,int i){int j;printf("%c",G->vexs[i]);visited[i]=TRUE;for(j=0;j<G->n;j++){if(G->edges[i][j]==1 && ! visited[j]){M_DFS(G,j);}}}void DFS(MGraph *G){int i;for(i=0;i<G->n;i++){visited[i]=FALSE;}for(i=0;i<G->n;i++){if(!visited[i])M_DFS(G,i);}}void BFS(MGraph *G,int k){int i,j,f=0,r=0;int cq[Max];for(i=0;i<G->n;i++){visited[i]=FALSE;}for(i=0;i<G->n;i++){cq[i]=-1;}printf("%c",G->vexs[k]);visited[k]=TRUE;cq[r]=k;while(cq[f]!=-1){i=cq[f];f++;for(j=0;j<G->n;j++){if(G->edges[i][j]==1&&!visited[j]){printf("%c",G->vexs[j]);visited[j]=TRUE;r++;cq[r]=j;}}}}邻接链表作为存储结构#include <stdio.h>#include <stdlib.h>#define Max 50typedef struct Node{int adjvex;struct Node *next;}EdgeNode;typedef struct vNode{char vertex;EdgeNode *firstedge;}VertexNode;typedef VertexNode AdjList[Max];typedef struct{AdjList adjlist;int n,e;}ALGraph;void Creat_ALGraph(ALGraph *G);void DFSM(ALGraph *G,int i);void DFS(ALGraph *G);void BFS(ALGraph *G,int k);void main(){int i;ALGraph *G;G=(ALGraph *)malloc(sizeof(ALGraph));Creat_ALGraph(G);printf("深度优先遍历: ");DFS(G);printf("\n");printf("广度优先遍历: ");BFS(G,3);}void Creat_ALGraph(ALGraph *G){int i,j,k;char a;EdgeNode *s;printf("请输入顶点数n和边数e：以英文状态下\",\"分隔:\n");scanf("%d,%d",&G->n,&G->e);scanf("%c",&a);printf("请输入顶点编号:\n");for(i=0;i<G->n;i++){scanf("%c",&a);G->adjlist[i].vertex=a;G->adjlist[i].firstedge=NULL;}printf("输入边,创建邻接矩阵,以英文状态下\",\"分隔\n");for(k=0;k<G->e;k++){scanf("%d,%d",&i,&j);s=(EdgeNode *)malloc(sizeof(EdgeNode));s->adjvex=j;s->next=G->adjlist[i].firstedge;G->adjlist[i].firstedge=s;s=(EdgeNode *)malloc(sizeof(EdgeNode));s->adjvex=i;s->next=G->adjlist[j].firstedge;G->adjlist[j].firstedge=s;}}typedef enum{FALSE,TRUE} Boolean;Boolean visited[Max];void DFSM(ALGraph *G,int i){EdgeNode *p;printf("%c",G->adjlist[i].vertex);visited[i]=TRUE;p=G->adjlist[i].firstedge;while(p){if(! visited[p->adjvex])DFSM(G,p->adjvex);p=p->next;}}void DFS(ALGraph *G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE;for(i=0;i<G->n;i++)if(!visited[i]){DFSM(G,i);}}void BFS(ALGraph *G,int k){int i,f=0,r=0; EdgeNode *p;int cq[Max];for(i=0;i<G->n;i++)visited[i]=FALSE;for(i=0;i<=G->n;i++)cq[i]=-1;printf("%c",G->adjlist[k].vertex);visited[k]=TRUE;cq[r]=k;while(cq[f]!=-1){i=cq[f]; f=f+1;p=G->adjlist[i].firstedge;while(p){if(!visited[p->adjvex]){printf("%c",G->adjlist[p->adjvex].vertex);visited[p->adjvex]=TRUE;r=r+1; cq[r]=p->adjvex;}p=p->next;}}}。