数据结构实验报告2
数据结构实验报告_实验报告_
数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是小编给大家整理收集的数据结构实验报告，供大家阅读参考。
数据结构实验报告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一.实验内容：实现哈夫曼编码的生成算法。
数据结构实验报告实验总结
数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。
通过实验，我对这些数据结构的特点、操作和应用有了更深入的了解。
下面对每一部分实验进行总结。
实验一：线性表的基本操作线性表是一种常见的数据结构，本实验要求实现线性表的基本操作，包括插入、删除、查找、遍历等。
在实验过程中，我对线性表的结构和实现方式有了更清晰的认识，掌握了用数组和链表两种方式实现线性表的方法。
实验二：栈的应用栈是一种后进先出（LIFO）的数据结构，本实验要求利用栈实现简单的括号匹配和后缀表达式计算。
通过实验，我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算，有效地解决了对应的问题。
实验三：队列的应用队列是一种先进先出（FIFO）的数据结构，本实验要求利用队列实现银行排队和迷宫求解。
通过实验，我对队列的应用有了更加深入的了解，了解到队列可以解决需要按顺序处理的问题，如排队和迷宫求解等。
实验四：链表的应用链表是一种常用的数据结构，本实验要求利用链表实现学生信息管理系统。
通过实验，我对链表的应用有了更深入的了解，了解到链表可以方便地实现对于数据的插入、删除和修改等操作，并且可以动态地调整链表的长度，适应不同的需求。
通过本次实验，我掌握了线性表、栈、队列和链表的基本操作，并了解了它们的特点和应用方式。
同时，通过实际编程的过程，我对于数据结构的实现方式和效果有了更直观的认识，也锻炼了自己的编程能力和解决问题的能力。
在实验过程中，我遇到了一些问题，如程序逻辑错误和内存泄漏等，但通过调试和修改，最终成功解决了这些问题，对自己的能力也有了更多的信心。
通过本次实验，我深刻体会到了理论与实践的结合的重要性，也对于数据结构这门课程有了更加深入的理解。
总之，本次数据结构实验给予了我很多有益的启发和收获，对于数据结构的概念、特点和应用有了更深入的理解。
在以后的学习中，我会继续加强对数据结构的学习和研究，不断提高自己的编程能力和解决问题的能力。
数据结构实验报告
数据结构实验报告
本次数据结构实验的任务主要包括两部分，分别是学习使用链表数据结构和掌握链表排序算法。
在此基础上，我们完成了一组关于链表基本操作和排序算法的实验。
实验一：链表基本操作
在这个实验中，我们学习了链表的插入、删除、查找等基本操作。
链表的插入和删除操作是通过一个链表节点来实现的。
链表节点包括一个数据域和一个指向下一个节点的指针域。
通过修改指针域，我们就可以实现节点的插入和删除操作。
具体来说，我们编写了一个基本的链表程序，其中包括链表头指针初始化、链表节点插入、链表节点删除、查找指定节点等操作。
通过对程序的调试和功能测试，我们验证了链表操作的正确性。
实验二：链表排序算法
在这个实验中，我们学习了链表排序算法，并编写了链表的快速排序和归并排序两种算法。
快速排序是一种分治思想的排序算法，通过选择一个基准元素，分别将小于和大于基准元素的元素分别放在它的左右两边，再递归地对左右两个子序列进行排序，最终得到有序序列。
归并排序是另一种经典的排序算法，它利用归并思想，将两个有序序列合并成一个更大的有序序列，这个过程不断重复，最终得到完整的有序序列。
通过实现这两种排序算法，并在大样本数据下进行测试，我们验证了算法的正确性和效率。
实验总结：
通过本次实验，我们深入学习了链表数据结构的相关基本操作和排序算法的实现原理。
同时，在实际编程实践中，我们也掌握了链表程序的调试、测试和优化技术。
这些都是我们今后从事软件开发工作需要掌握的重要技能，在这个方面的积累将会对我们有很大帮助。
数据结构实验报告 (2)
数据结构实验报告实验报告数据结构实验报告应包含以下几个部分：1. 实验目的：简要介绍实验的目的和意义。
2. 原理介绍：详细介绍本次实验所涉及的数据结构原理，包括数据结构的定义、特性以及相关算法或操作。
3. 实验内容：详细描述本次实验的具体内容，包括实验要求和实验步骤。
4. 实验结果：展示实验的结果，以适当的方式呈现实验数据和实验输出。
可以包括图表、表格、代码等。
5. 分析讨论：分析实验结果，讨论实验结果与预期结果的差异，并给出相应的解释。
6. 实验总结：对本次实验的总结和评价，包括实验的收获、不足之处以及改进的建议。
以下是一个简单的数据结构实验报告的范例：实验目的：本次实验的目的是熟悉链表数据结构的概念和基本操作，包括链表的插入、删除和查找等。
原理介绍：链表是一种常用的数据结构，它由一组节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
链表中的节点可以通过指针相互连接，从而形成一串有序的数据。
链表不同于数组，它的插入和删除操作十分高效，但查找效率较低。
实验内容：本次实验要求实现一个链表，并在链表中实现插入、删除和查找操作。
首先，定义一个节点结构，并实现节点的插入和删除操作；其次，实现查找操作，并根据查找结果返回节点位置或者相关信息。
实验结果：经过实验，我们得到了以下结果：在链表中插入节点的时间复杂度为O(1)，删除节点的时间复杂度为O(1)，查找节点的时间复杂度为O(n)。
分析讨论：从结果可以看出，链表的插入和删除操作的效率较高，但查找操作的效率较低。
这是因为链表中的节点没有连续的存储空间，所以需要遍历整个链表才能找到目标节点。
如果需要频繁进行查找操作，可以考虑使用其他数据结构，如二叉搜索树或哈希表。
实验总结：通过本次实验，我们深入了解了链表数据结构的原理和基本操作，并实现了一个简单的链表。
在以后的学习和实践中，我们可以根据实际需求选择合适的数据结构，以提高程序的效率和性能。
此外，本次实验也让我们更加熟悉了编程的过程和技巧。
数据结构实验2报告总结
一实验目的和要求理解二叉树的基本概念，熟练使用多种表示法构造二叉树，掌握采用二叉链表存储结构实现二叉树的构造、遍历、插入、删除等操作算法；理解线索二叉树的作用，掌握获得线索二叉树节点在指定遍历次序下的前驱或后继结点的方法；理解哈弗曼编码和哈弗曼树的作用，掌握由指定文本求得哈弗曼编码的方法。
理解树的基本概念，熟悉树的多种存储结构，掌握采用孩子兄弟链表存储结构实现树的遍历、插入、删除等操作算法。
通过研究树和二叉树，深刻理解链式存储结构用于表达非线性结构的作用，掌握采用递归算法实现递归数据结构基本操作的设计方法。
二题目及题意分析题目：插入x元素作为p结点的第i个孩子分析：以中国城市作为元素,以插入孩子结点的方式构造一棵树，找到结点p，p不为空时，若p的孩子结点为空，则直接插入x元素作为p的孩子;若p的孩子结点不为空，插入的x元素的位置n小于等于1时，将x元素直接插在最前面;若n大于1时，查找插入的位置执行插入。
三设计方案和功能说明源程序如下：TreeNode.htemplate<class T>class TreeNode //数的孩子兄弟链表结点类{public: //数据域，保存元素T data;TreeNode<T>* child,*sibling; //指针域，分别指向孩子兄弟结点TreeNode<T>(T data,TreeNode<T>*child=NULL,TreeNode<T>*sibling=NULL){this->data=data;this->child=child;this->sibling=sibling;}};Tree.h#include<iostream.h>#include"TreeNode.h" //树的孩子兄弟链表节点类template<class T>class Tree //树类{public:TreeNode<T>*root; //指向根结点Tree(); //构造空树bool isEmpty();//判断是否空树TreeNode<T>* insertChild(TreeNode<T>*p,T value); // 插入value作为结点p的孩子TreeNode<T>* insertChild(TreeNode<T>*p,T x,int i);// 插入x元素作为p结点的第i 个孩子friend ostream&operator<<(ostream&out,Tree<T>&tree);//先根次序遍历树并以树的横向凹入表示法输出树void preOrder(TreeNode<T> *p,int i);};template<class T>Tree<T>::Tree() //构造空树{root=NULL;}template<class T>bool Tree<T>::isEmpty()//判断是否空树{return root==NULL;}template<class T>TreeNode<T>* Tree<T>::insertChild(TreeNode<T>*p,T value) //插入value作为结点p的孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T> (value);if(p->child==NULL)p->child=q;else{p=p->child;while(p->sibling!=NULL)p=p->sibling;p->sibling=q;}}return q;}template<class T>TreeNode<T>*Tree<T>::insertChild(TreeNode<T>* p,T x,int i)// 插入x元素作为p结点的第i 个孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T>(x);if(p->child==NULL)p->child=q;else{{if(i<=1)//带有容错功能{p->child=new TreeNode<T>(x,NULL,p->child);return p->child;}p=p->child;for(int j=1;p->sibling!=NULL&&j<i-1;j++)p=p->sibling;if( p->sibling==NULL)p->sibling=q;elsep->sibling=new TreeNode<T>(x,NULL,p->sibling);}}}return q;}template<class T>void Tree<T>::preOrder(TreeNode<T> *p,int i){if(p!=NULL){for(int j=0;j<i;j++)cout<<"\t";cout<<p->data<<endl;preOrder(p->child,i+1);preOrder(p->sibling,i);}}template<class T>ostream&operator<<(ostream&out,Tree<T> &tree)//先根次序遍历树并以树的横向凹入表示法输出树{tree.preOrder(tree.root,0);return out;}Main.cpp#include "Tree.h"TreeNode<char*>*aa;void make(Tree<char*>&tree){tree.root=new TreeNode<char*>("中国");tree.insertChild(tree.root,"北京");tree.insertChild(tree.root,"上海");TreeNode<char*>*js=tree.insertChild(tree.root,"江苏省");tree.insertChild(js,"南京市");tree.insertChild(js,"苏州市");TreeNode<char*> *zj=tree.insertChild(tree.root,"浙江省");tree.insertChild(zj,"杭州市");tree.insertChild(zj,"宁波市");TreeNode<char*> *sx=tree.insertChild(tree.root,"山西省");tree.insertChild(sx,"太原市");tree.insertChild(sx,"大同市");aa=zj;}int main(){Tree<char*>tree;make(tree);cout<<tree;tree.insertChild(aa,"无锡市",2);cout<<tree;return 0;}四运行结果及分析1插入位置小于等于1（即n<=1）n=-2时n=0时n=1时2插入位置大于1（即n>1）n=2时五实验总结通过实验理解了树及二叉树的存储结构熟悉掌握了孩子兄弟链表的存储结构实现，以及遍历、查找、删除等操作，深刻理解实现链式存储结构表达非线性的树存储结构。
数据结构实验报告2
数据结构实验报告2数据结构实验报告21、实验目的本次实验的目的是通过使用数据结构来解决一个特定的问题。
具体而言，我们将会使用某种数据结构（例如链表、堆栈、队列等）来实现一个特定功能，并对其性能进行评估。
2、实验背景在本次实验中，我们将会探索数据结构在解决实际问题中的应用。
数据结构是计算机科学的重要组成部分，它提供了一种组织和管理数据的方式，以便能够高效地访问和操作这些数据。
3、实验内容在本次实验中，我们选择了一种经典的数据结构，以实现一个特定的功能。
具体而言，我们将会使用链表来实现一个简单的联系人管理系统。
3.1 数据结构选择我们选择了链表作为联系人管理系统的数据结构。
链表是一种灵活的数据结构，它能够动态地增加或删除元素，并且支持高效的插入和删除操作。
3.2 实现功能我们的联系人管理系统将会具有以下功能：- 添加联系人：用户可以输入联系人的姓名、方式号码等信息，并将其添加到联系人列表中。
- 删除联系人：用户可以选择要删除的联系人，并从列表中删除该联系人。
- 查找联系人：用户可以根据姓名或方式号码来查找联系人，并显示相关信息。
- 显示所有联系人：系统将会将所有联系人按照姓名的字母顺序进行排序，并将其显示在屏幕上。
4、实验步骤下面是本次实验的具体步骤：4.1 初始化联系人管理系统在系统开始之前，我们需要初始化联系人管理系统。
这包括创建一个空的联系人列表，并提供用户菜单来选择相应功能。
4.2 添加联系人用户可以选择添加联系人的功能，并输入联系人的相关信息。
系统将会将联系人添加到联系人列表中。
4.3 删除联系人用户可以选择删除联系人的功能，并输入要删除联系人的姓名或方式号码。
系统将会在联系人列表中查找并删除相应联系人。
4.4 查找联系人用户可以选择查找联系人的功能，并输入要查找联系人的姓名或方式号码。
系统将会在联系人列表中查找相应联系人，并显示其相关信息。
4.5 显示所有联系人用户可以选择显示所有联系人的功能。
数据结构实验报告2
数据结构实验报告2一、实验目的本次数据结构实验旨在通过实际操作和编程实践，深入理解和掌握常见的数据结构，如链表、栈、队列、树等，并能够运用所学知识解决实际问题，提高编程能力和算法设计能力。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容（一）链表的实现与操作1、单向链表的创建首先，定义了链表节点的结构体，包含数据域和指向下一个节点的指针域。
然后，通过函数实现了单向链表的创建，从用户输入获取节点的数据，依次创建新节点并连接起来。
2、链表的遍历编写函数实现对单向链表的遍历，依次输出每个节点的数据。
3、链表的插入与删除实现了在指定位置插入节点和删除指定节点的功能。
插入操作时，需要找到插入位置的前一个节点，修改指针完成插入。
删除操作时，同样找到要删除节点的前一个节点，修改指针并释放删除节点的内存。
（二）栈的实现与应用1、栈的基本操作使用数组实现了栈的数据结构，包括入栈、出栈、判断栈空和获取栈顶元素等操作。
2、表达式求值利用栈来实现表达式求值的功能。
将表达式中的数字和运算符分别入栈，按照运算规则进行计算。
（三）队列的实现与应用1、队列的基本操作使用循环数组实现了队列，包括入队、出队、判断队空和队满等操作。
2、模拟银行排队系统通过创建队列来模拟银行客户的排队情况，实现客户的入队和出队操作，统计平均等待时间等。
（四）二叉树的遍历1、二叉树的创建采用递归的方式创建二叉树，用户输入节点数据，构建二叉树的结构。
2、先序、中序和后序遍历分别实现了二叉树的先序遍历、中序遍历和后序遍历，并输出遍历结果。
四、实验结果与分析（一）链表实验结果成功创建、遍历、插入和删除单向链表。
通过对链表的操作，深入理解了链表的动态存储特性和指针的运用。
在插入和删除操作中，能够正确处理指针的修改和内存的释放，避免了内存泄漏和指针错误。
（二）栈实验结果栈的基本操作运行正常，能够正确实现入栈、出栈等功能。
数据结构实验报告二二叉树实验
实验报告课程名称：数据结构
第 1 页共4 页
五、实验总结（包括心得体会、问题回答及实验改进意见，可附页）
这次实验主要是建立二叉树，和二叉树的先序、中序、后续遍历算法。
通过这次实验，我巩固了二叉树这部分知识,从中体会理论知识的重要性。
在做实验之前，要充分的理解本次实验的理论依据，这样才能达到事半功倍的效果。
如果在没有真正理解实验原理之盲目的开始实验，只会浪费时间和精力。
例如进行二叉树的遍历的时候，要先理解各种遍历的特点。
先序遍历是先遍历根节点，再依次先序遍历左右子树。
中序遍历是先中序遍历左子树，再访问根节点，最后中序遍历右子树。
而后序遍历则是先依次后续遍历左右子树，再访问根节点。
掌握了这些，在实验中我们就可以融会贯通，举一反三。
其次要根据不光要懂得代码的原理，还要对题目有深刻的了解，要明白二叉树的画法，在纸上先进行自我演练，对照代码验证自己写的正确性。
第 3 页共4 页
第 4 页共4 页。
数据结构实验报告2篇
数据结构实验报告数据结构实验报告精选2篇（一）实验目的：1. 熟悉数据结构的基本概念和基本操作；2. 掌握线性表、栈、队列、链表等经典数据结构的实现方法；3. 掌握数据结构在实际问题中的应用。
实验内容：本次实验主要包括以下几个部分：1. 线性表的实现方法，包括顺序表和链表，分别使用数组和链表来实现线性表的基本操作；2. 栈的实现方法，包括顺序栈和链式栈，分别使用数组和链表来实现栈的基本操作；3. 队列的实现方法，包括顺序队列和链式队列，分别使用数组和链表来实现队列的基本操作；4. 链表的实现方法，包括单链表、双链表和循环链表，分别使用指针链、双向链和循环链来实现链表的基本操作；5. 综合应用，使用各种数据结构来解决实际问题，例如使用栈来实现括号匹配、使用队列来实现马铃薯游戏等。
实验步骤及结果：1. 线性表的实现方法：a) 顺序表的基本操作：创建表、插入元素、删除元素、查找元素等；b) 链表的基本操作：插入节点、删除节点、查找节点等；c) 比较顺序表和链表的优缺点，分析适用场景。
结果：通过实验，确认了顺序表适用于频繁查找元素的情况，而链表适用于频繁插入和删除节点的情况。
2. 栈的实现方法：a) 顺序栈的基本操作：进栈、出栈、判空、判满等；b) 链式栈的基本操作：进栈、出栈、判空、判满等。
结果：通过实验，掌握了栈的基本操作，并了解了栈的特性和应用场景，例如括号匹配。
3. 队列的实现方法：a) 顺序队列的基本操作：入队、出队、判空、判满等；b) 链式队列的基本操作：入队、出队、判空、判满等。
结果：通过实验，掌握了队列的基本操作，并了解了队列的特性和应用场景，例如马铃薯游戏。
4. 链表的实现方法：a) 单链表的基本操作：插入节点、删除节点、查找节点等；b) 双链表的基本操作：插入节点、删除节点、查找节点等；c) 循环链表的基本操作：插入节点、删除节点、查找节点等。
结果：通过实验，掌握了链表的基本操作，并了解了链表的特性和应用场景。
数据结构_迷宫求解_实验报告 北邮
数据结构实验报告实验名称：实验二——利用栈结构实现迷宫求解问题学生姓名：班级：班内序号：学号：日期：2012年11月19日一、实验目的1、进一步掌握指针、模板类、异常处理的使用2、掌握栈的操作的实现方法3、掌握队列的操作的实现方法4、学习使用栈解决实际问题的能力5、学习使用队列解决实际问题的能力二、实验要求：利用栈结构实现迷宫求解问题。
迷宫求解问题如下：心理学家把一只老鼠从一个无顶盖的大盒子的入口赶进迷宫，迷宫中设置很多隔壁，对前进方向形成了多处障碍，心理学家在迷宫的唯一出口放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口，测试算法的迷宫如下图所示。
提示：1、可以使用递归或非递归两种方法实现2、老鼠能够记住已经走过的路，不会反复走重复的路径3、可以自己任意设置迷宫的大小和障碍4、使用“穷举求解”的方法三、程序分析1、存储结构栈存储结构；示意图；2、关键算法分析A、绘制迷宫；伪代码：1、输出迷宫的大小及全部设置为障碍；2、根据键盘的输入绘制迷宫的路线，起始点和终点；void draw()//绘制迷宫障碍{k=getch();switch(int(k)){case 105://上if(by>5){by--;j--;}break;case 107://下if(by<M+4){by++;j++;}break;case 106://左if(bx>2){bx=bx-2;i--;}break;case 108://右if(bx<2*N){bx=bx+2;i++;}break;case 114://'R'路map[i][j]=0;cout<<".";break;case 119://'W'墙map[i][j]=-3;cout<<"■";break;case 115://'S'起点s[0].x=i;//起点入栈s[0].y=j;top=1;map[i][j]=-1;cout<<k;break;case 101://'E'终点map[i][j]=-2;cout<<k;break;}gotoxy(bx,by);}B、路径寻找伪代码；1、向某一方向查找是否有路；2、如有遍历一下栈，看是否已经进栈，一进栈就舍弃，寻求下一个；无就让其进栈。
数据结构实验2——栈和队列实验报告
数据结构实验报告实验名称：实验2——栈和队列1 实验目的通过选择下面五个题目之一进行实现，掌握如下内容：进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力2 实验内容利用栈结构实现八皇后问题。
八皇后问题19世纪著名的数学家高斯于1850年提出的。
他的问题是：在8*8的棋盘上放置8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列、同一斜线上。
请设计算法打印所有可能的摆放方法。
提示：1、可以使用递归或非递归两种方法实现2、实现一个关键算法：判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析主程序：#include<iostream>using namespace std;const int StackSize=8; //皇后的个数int num=0;template <class T>class SeqStack //定义顺序栈模板类{public:SeqStack(){top=-1;} //构造函数，初始化空栈void Push(T x); //入栈操作void Pop();//出栈操作void PlaceQueen(int row); //放置皇后bool Judgement();//判断是否符合条件void Print();//输出符合条件的皇后排列bool Empty(){if(top==-1) return true;else return false;}; //判断栈是否为空private:T data[StackSize]; //定义数组int top; //栈顶指针};template <class T>void SeqStack<T>::Push(T x) //入栈操作{if(top>=StackSize-1) throw"上溢";top++;//栈顶指针上移data[top]=x;}template <class T>void SeqStack<T>::Pop()//出栈操作{if(Empty()) throw"下溢";top--;//栈顶指针下移}template <class T>bool SeqStack<T>::Judgement()//判断该位置是否合适{for(int i=0;i<top;i++)if(data[top]==data[i]||(abs(data[top]-data[i]))==(top-i))//判断是否满足任意两个皇后不在同列同一斜线return false;return true;}template <class T>void SeqStack<T>::PlaceQueen(int row) //放置皇后{for (int i=0;i<StackSize;i++){Push(i); //入栈if (Judgement())//判断位置是否合适{if (row<StackSize-1)PlaceQueen(row+1); //如果合适满足条件则放置一个皇后,递归调用else{num++;//不满足条件则到下一行Print();//输出符合条件的皇后}}Pop();//出栈}}template <class T>void SeqStack<T>::Print()//输出皇后函数{cout<<"NO."<<num<<":"<<endl; for(int i=0;i<StackSize;i++){for(int j=0;j<data[i];j++){cout<<"□";}cout<<"■";for(int j=StackSize-1;j>data[i];j--){cout<<"□";}cout<<endl;}cout<<endl;}void main(){SeqStack<int> Queen;Queen.PlaceQueen(0);cout<<"总共有"<<num<<"种摆放方法。
数据结构实验报告二(栈、队列与杨辉三角)
《数据结构》实验报告项目名称栈、队列与杨辉三角专业班级软件工程工科试验班学号3903120128姓名谢江实验成绩：批阅教师：2012年5月22 日实验1《单链表的建立与约瑟夫问题》实验学时：实验地点：寝室与实验室实验日期：2012年5月22日1．需求分析实验2 主要是关于栈。
队列的建立以及杨辉三角问题的解决（队列运用）2．概要设计以及详细设计（1）栈class Stack{public:Stack();bool empty();//判断栈是否为空T peek();//显示栈顶元素void push(T value);//入栈T pop();//出栈int getSize();//当前栈中元素的数量private:T *elements;//数组指针int size;//栈中的元素数量int capacity;//栈的容量void ensureCapacity();//确认栈的容量是否大于元素数量};（2）队列class Queue{public:Queue();void enQueue(T element);//元素入队T deQueue();//元素出对，如果没有元素，抛出异常int getSize();//获取队列大小private:LinkedList<T> list;//定义表};3．调试分析内容包括：调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论和分析；算法的时空分析(包括基本操作和其他算法的时间复杂度和空间复杂度的分析)和改进设想；经验和体会等。
个人标记:能建立顺序栈，以及链表顺序队列，对于比较复杂的链栈、循环队列等比较不熟悉，杨辉三角问题存在问题此次报告暂时不交，还有就是抛出异常的问题，例如：T deQueue()throw (runtime_error);//元素出对，如果没有元素，抛出异常会提示警告：C++ exception specification ignored except to indicate a function is not_declspec(nothrow)于是尽可能用if(…)throw runtime_error,就不报错了4．附录（1）栈Stack.h*****************************//采用数组的方式进行栈的操作#ifndef STACK_H#define STACK_Htemplate<typename T>class Stack{public:Stack();bool empty();//判断栈是否为空T peek();//显示栈顶元素void push(T value);//入栈T pop();//出栈int getSize();//当前栈中元素的数量private:T *elements;//数组指针int size;//栈中的元素数量int capacity;//栈的容量void ensureCapacity();//确认栈的容量是否大于元素数量};template<typename T>Stack<T>::Stack(){capacity = 10;//初始栈的大小size = 0;//初始元素的数量elements = new T[capacity];//建立指针}template<typename T>bool Stack<T>::empty(){if(size == 0)return true;elsereturn false;}template<typename T>//只显示栈顶元素并不出栈T Stack<T>::peek(){return elements[size - 1];}template<typename T>void Stack<T>::ensureCapacity(){if(size >= capacity)//如果满足进行指针的更换{T *old = elements;capacity = size + 1;elements = new T[capacity];for(int i = 0; i < size; i++)elements[i] = old[i];delete old;}}template<typename T>void Stack<T>::push(T value){ensureCapacity();//入栈前进行栈是否溢出的判断elements[size++] = value;}template<typename T>T Stack<T>::pop(){return elements[--size];}template<typename T>int Stack<T>::getSize(){return size;}#endif*************************************TestStack.cpp*************************************#include<iostream>#include"Stack.h"using namespace std;int main(){Stack<int> intS;cout << "before push size of intStack is: " << intS.getSize() << endl;//统计入栈前栈的大小for(int i = 0; i < 10; i++){int num;cout << "enter num: ";cin >> num;intS.push(num);}cout << "now size of intStack is: " << intS.getSize() << endl;//统计入栈后栈的大小while(!intS.empty()){cout << intS.pop() << " out " << endl;}cout << "after pop size of intStack is: " << intS.getSize() << endl;//出站后栈的大小system("pause");return 0;}##################################################(2)队列LinkedList.h******************************************#ifndef LINKEDLIST_H#define LINKEDLIST_H#include<stdexcept>using namespace std;template<typename T>class Queue;//前视定义，否则无法友元template<typename T>class Node{public :T element;//节点数据域Node<T> *next;//指向下指针Node(){next = NULL;}Node(T element){this -> element = element;next = NULL;}};template<typename T>class LinkedList{public:LinkedList();T removeFirst();//移除并返回表头元素void addLast(T element);//尾端插入新元素int getSize();//获取表的大小private:Node<T> *head, *tail;//定义头节点、尾节点int size;};template<typename T>LinkedList<T>::LinkedList()//初始化链表NULL{head = tail = NULL;size = 0;}template<typename T>void LinkedList<T>::addLast(T element){if(tail == NULL){head = tail = new Node<T>(element);}else{tail ->next = new Node<T>(element);tail = tail ->next;}size++;//作添加工作，size++}template<typename T>T LinkedList<T>::removeFirst(){if(size == 0)throw runtime_error("No elements");//抛出异常情况else{//删除并返回头节点元素，把下一节点作为新的头节点Node<T> *temp = head;head = head ->next;if(head == NULL)tail = NULL;size--;//作删除工作，size--T element = temp ->element;delete temp;return element;}}template<typename T>int LinkedList<T>::getSize()//返回size{return size;}#endif****************************************Queue.h***********************************#ifndef QUEUE_H#define QUEUE_H#include"LinkedList.h"#include<stdexcept>using namespace std;template<typename T>class Queue{public:Queue();void enQueue(T element);//元素入队T deQueue();//元素出对，如果没有元素，抛出异常int getSize();//获取队列大小private:LinkedList<T> list;//定义表};template<typename T>Queue<T>::Queue(){}//空的构造函数template<typename T>void Queue<T>::enQueue(T element){list.addLast(element);//入队（后插）}template<typename T>T Queue<T>::deQueue(){return list.removeFirst();//出对（前删）}template<typename T>int Queue<T>::getSize(){return list.getSize();}#endif******************************************* TestQueue.cpp*******************************************#include<iostream>#include<stdexcept>#include"Queue.h"using namespace std;int main(){Queue<int> q;cout << "before enQueue size is: " << q.getSize() << endl;for(int i = 0; i < 10; i++){q.enQueue(i);cout << i << " enter queue" << endl;}cout << "after enQueue size si: " << q.getSize() << endl;while(q.getSize()!=0){cout << q.deQueue() << "out queue" << endl;}cout << "after deQueue size is: " << q.getSize() << endl;system("pause");return 0;}。
南邮数据结构实验报告
南邮数据结构实验报告实验目的，通过本次实验，我们旨在加深对数据结构的理解，掌握数据结构的基本操作和算法设计能力，提高对数据结构的应用能力和实际问题的解决能力。
一、实验内容。
1. 实验一，线性表的基本操作。
本次实验中，我们首先学习了线性表的基本概念和操作，包括插入、删除、查找等操作，并通过实际编程操作来加深对线性表的理解。
2. 实验二，栈和队列的应用。
在实验二中，我们通过实际编程操作来学习栈和队列的应用，包括中缀表达式转换为后缀表达式、栈的应用、队列的应用等内容。
3. 实验三，树和二叉树的基本操作。
实验三中，我们学习了树和二叉树的基本概念和操作，包括树的遍历、二叉树的建立和遍历等内容，并通过实际编程操作来加深对树和二叉树的理解。
4. 实验四，图的基本操作。
最后，我们学习了图的基本概念和操作，包括图的存储结构、图的遍历等内容，并通过实际编程操作来加深对图的理解。
二、实验过程。
在实验过程中，我们首先对实验内容进行了深入的学习和理解，掌握了数据结构的基本概念和操作方法。
然后，我们通过实际编程操作来加深对数据结构的理解，并通过调试和修改程序来提高对数据结构的应用能力和实际问题的解决能力。
在实验过程中，我们遇到了一些问题，但通过不懈的努力和团队合作，最终顺利完成了实验任务。
三、实验结果与分析。
通过本次实验，我们深入理解了数据结构的基本概念和操作方法，掌握了线性表、栈、队列、树、二叉树和图的基本操作，并通过实际编程操作加深了对数据结构的理解。
同时，我们也提高了对数据结构的应用能力和实际问题的解决能力，为今后的学习和工作打下了坚实的基础。
四、实验总结。
通过本次实验，我们不仅加深了对数据结构的理解，还提高了对数据结构的应用能力和实际问题的解决能力。
在今后的学习和工作中，我们将继续努力，不断提升自己的专业能力，为将来的发展打下坚实的基础。
以上就是本次实验的报告内容，谢谢！。
北邮数据结构实验报告二_栈和队列
2009级数据结构实验报告实验名称：实验二栈和队列学生姓名：班级：班内序号：学号：日期：2010年12月18日实验要求题目四用栈做计算器。
设计一个算术四则运算表达式求值的简单计算器。
表达式求值是程序设计语言编译中最近本的问题，它要求把一个表达式翻译成能够直接求值的序列。
基本要求：输入中缀表达式能够转化成后缀表达式，比如输入中缀表达式“(A+B)*C”，输出“AB+C*”2、操作数使用单字母变量A、B、C等表示，操作符仅为+、-、*、/、（和）；3、能够对变量A、B、C等赋值，得出正确的计算结果2. 程序分析首先，程序要求用户输入一个符号表达式，只能包含字母、+、-、*、/ 以及）和（，之后程序会用一个TurnInfixToPostfix（）函数将表达式转化成后缀表达式存入一个栈中，转化过程借用逆波兰算法，建立一个符号栈，遍历用户输入的表达式，如果是字母，则直接输出，如果是运算符，则压入符号栈中（包括括号），在压栈的时候又需要注意，先要检查压栈前栈顶元素的优先级，如果优先级高于要压入的符号则直接压入该符号，否则要弹栈直到栈顶元素的优先级小于该元素的优先级然后才将该符号压入栈中（在压栈的时候会涉及到栈中有括号的情况，具体细节下面会说到），将转化的后缀表达式存入栈postfix，在输出的时候只要弹栈就行。
然后，要求用户逐个输入表达式中的字母的值，这时候，需要遍历当时在转化后缀表达式的时候过度容器vec_intoposfix，如果是字母则要求用户输入数值，压入用于计算的后缀表达式容器，如果是操作符则直接压入。
最后，在利用栈来计算值的时候，利用一个递归函数，就是一次弹栈，如果是操作符则先保存起来，接着继续弹栈，如果接下来的两个元素都为数字，就将这两个数字做相应的运算，然后压栈，如此反复，最后压入栈的元素就是表达式的值。
至此，程序的功能全部实现。
2.1 存储结构[内容要求]1、存储结构：顺序表、单链表或其他存储结构，需要画示意图，可参考书上P59页图2-92.2 关键算法分析关键算法一：将中缀表达式转化为后缀表达式VoidTurnInfixToPostfix(vector<char>&vec,stack<char>&sta,vector<char>&vecfix,stack< char>&stafix)1、 {2、int priority(-1);3、4、for (vector<char>::iterator itr=vec.begin();itr!=vec.end();itr++)5、{6、if(isLetter(*itr))7、{8、vecfix.push_back(*itr);9、}10、if (isOperator(*itr))11、{12、if(!sta.empty()) priority=getPriority(sta.top());13、else priority=-1;14、if (priority<getPriority(*itr)||priority==3&&sta.top()!=')')15、{16、sta.push(*itr);17、}18、else19、{20、if (sta.top()!=')')21、{22、while(priority>=getPriority(*itr)&&sta.top()!='(')23、{24、vecfix.push_back(sta.top());25、if (!sta.empty())26、{27、sta.pop();28、if(!sta.empty()) priority=getPriority(sta.top());29、else priority=-1;30、}31、else32、break;33、}34、sta.push(*itr);35、}36、else if(sta.top()==')')37、{38、while (sta.top()!='(')39、{40、vecfix.push_back(sta.top());41、if (!sta.empty()&&sta.top()!='(')42、{43、sta.pop();44、}45、else46、break;47、}48、}49、}50、51、52、}53、54、}55、for (vector<char>::iteratoritrfix=vecfix.end();itrfix!=vecfix.begin();--itrfix)56、stafix.push(*itrfix);57、stafix.push(*itrfix);58、}对表达式a + b * c – ( d – e) / f + g其符号栈的变化过程，红色表示未压栈的符号。
数据结构课程实验报告
数据结构课程实验报告目录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. 实验总结通过本次实验，学生将对数据结构与算法设计有更深入的了解，并能将所学知识应用到实际问题中，提高自己的实践能力和解决问题的能力。
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
};
typedef struct pw PW;
//定义链表结点
struct node
{
PW data;
struct node * next;
};
typedef struct node NODE;
NODE *create(int n); //建立单链表
void input(NODE *s,int i); //输入第i个评委信息
（5）遍历链表，累加求和，计算总分及平均分，并输出相关信息。
完整程序
//实验1.1线性表的链接存储结构
#include
#include
#include
#define PWRS 5 //定义评委人数
//定义评委信息
struct pw
{
char name[8]; //姓名
short age; //年龄
float score; //评分
NODE *create(int n)
{
NODE *head,*p,*q;
inti;
p=(NODE*)malloc(sizeof(NODE));
head=p; q=p; p->next=NULL;
for(i=1; i<=n; i++)
{
p=(NODE*)malloc(sizeof(NODE));
数据结构实验报告二
数据结构实验报告（实验名称）1.实验目标熟练掌握栈的顺序存储结构和链式存储结构。
熟练掌握栈的有关算法设计，并在顺序栈和链栈上实现。
根据具体给定的需求，合理设计并实现相关结构和算法。
2.实验内容和要求内容：通过顺序栈和链栈结构设计并实现一个顺序栈，编写算法实现下列问题的求解。
<1>利用顺序栈实现将10进制数转换为16进制数。
第一组数据：4第二组数据：11第三组数据：254第四组数据：1357<2>对一个合法的数学表达式来说，其中的各大小括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。
设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。
要求：顺序栈的实验要求顺序栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；程序有适当的注释。
链栈实验要求本次实验中的链栈结构指带头结点的单链表；链栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；程序有适当的注释。
3.数据结构设计顺序栈，链栈。
4.算法设计（除书上给出的基本运算（这部分不必给出设计思想），其它实验内容要给出算法设计思想）进制转换：先在函数中定义一个栈然后初始化栈，通过循环对x求余数，将余数放入栈中，循环取出栈中的元素，并判断其值，用switch-case，10-A，11-B，12-C，13-D，14-E，15-F。
判断符号是否配对：通过函数将栈传入，将栈中的元素放到一个数组中，然后通过循环给数组中的符号对应相反数数字，如“（”-1，“）”-（-1）。
判断是否合法时，将整数数组遍历相加，若和为0 ，表达式合法，若和不为0则不合法。
5.运行和测试顺序栈：1，2，链栈：1，26.总结和心得通过本次实验，很多东西还为掌握，要是不是的查书，查书时总结了一下内容栈是限定尽在表尾进行插入或者删除操作的线性表。
《数据结构》实验报告二(样例参考)
《数据结构》实验报告二系别：班级：学号：姓名：日期：指导教师：一、上机实验的问题和要求：单链表的查找、插入与删除。
设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求：1.从键盘输入10个字符，产生不带表头的单链表，并输入结点值。
2.从键盘输入1个字符，在单链表中查找该结点的位置。
若找到，则显示“找到了”；否则，则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。
5.（★）将单链表中值重复的结点删除，使所得的结果表中各结点值均不相同，输出单链表所有结点值，观察输出结果。
6.（★）删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。
7.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）1.程序结构：定义一个主函数和五个子函数（分别用来实现单链表的创建、查找、插入、删除及单链表的打印）。
2.数据结构：定义一个结构体，作为单链表的结点。
typedef struct stu /*DataType可以是任何相应的数据类型如int, float或char*/ {char Name[Max]; /*定义了数据域，这里存放的是一个字符型数组*/struct stu *next; /*定义了指针域*/}student;3.输入输出设计：创建单链表函数：student *create();输入：通过scanf( )函数及for语句为数据域定义，并定义指针域的指针所指的下一个结点。
数据结构实验报告（二）栈的应用
数据结构实验报告（⼆）栈的应⽤实验说明数据结构实验⼆ 栈的实验——栈的简单应⽤⼀、实验⽬的通过本实验使学⽣了解栈的简单应⽤，熟悉栈的特性及栈在顺序存储上的操作特点，深刻理解栈的基本操作与⽤栈解决应⽤问题的关系；特别训练学⽣使⽤栈解决实际问题的能⼒，为今后⽤栈解决相关问题奠定基础。
⼆、实验内容1.编程实现对给定的⼀组括号序列判断其是否匹配正确。
要求：（1）它必须成对出现，如“(”“)”是⼀对，“[”与“]”是⼀对；（2）出现时有严格的左右关系；（3）可以以嵌套的⽅式同时出现多组多括号，但必须是包含式嵌套，不允许交叉式嵌套。
⽐如“( )”、“[([][])]”这样是正确的，“[(])”或“([()))”或 “(()]”是不正确的。
（4）将处理的括号扩展为针对“()”“[]”“{}”三类。
2.编程实现⼀个简单的⾏编辑功能：⽤户可以输⼊⼀⾏内容，并可进⾏简易编辑。
要求：（1）遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效；（2）“@”表⽰之前的内容均⽆效。
实验报告1.实现功能描述编程实现对给定的⼀组括号序列判断其是否匹配正确，将处理的括号扩展为针对“()”“[]”“{}”三类，遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效；“@”表⽰之前的内容均⽆效。
2.⽅案⽐较与选择（1）可以使⽤栈和队列来实现。
因为栈的功能⾜以完成题⽬要求，所以初步打算使⽤栈来实现。
（2）因为编写⼀个标准的栈⽐较繁琐，⽽且本题中也没有⽤到所有栈的标准操作，所以通过模拟栈来完成本题。
（3）可以使⽤数组或链表来模拟栈。
因为括号匹配只有3对，所需空间不是很⼤，⼜因为特殊操作#、@可以在数组中通过-1和赋0值实现，因此选择了数组法来模拟栈。
3.设计算法描述（1）定义3个变量，分别⽤于记录()、[]、{}的出现次数。
遇到左符号时变量++，遇到右符号时--，变量为0时表⽰空栈。
当读到#时，再往前读⼀个字符，如果是()、[]、{}中的⼀种，则对其进⾏反向运算，即遇到右符号时++，遇到左符号时--。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》实验报告班级:10011006 姓名:刘恋学号:2010302521 E-mail:_1020383169@日期:10.12◎实验题目:使用键盘输入表达式，计算表达式的值并输出；将表达式转化成后缀表达式输出，利用后缀表达式求表达式的值并输出。
◎实验目的：训练对栈的使用，中缀变为后缀及表达式的计算。
◎实验内容：利用队栈变中缀为后缀计算求值。
一、需求分析1、本实验中，数据为整数，先建立一个链栈返回栈顶元素，输入表达式先判断表达式的正误，然后将中缀表达式变换为后缀表达式，继而计算求值。
2、表达式以后缀表达式形式输出，求值结果输出为整数。
3、程序所执行的命令有：定义结构体，判断表达式的正误，建立链栈并初始化，字符串的输入，运算符高低的判断，表达式求值。
4、测试数据：当输入表达式为6-5*(2+3)/5时，输出结果为后缀表达式为6 5 2 3 + * 5 / - 结果为1.二概要设计为了实现上述操作，应以链栈为存储结构。
1. 基本操作：struct node定义结构体。
Searchexpression(char string1[])表达式的判断node *Initialization()建立初始化链栈node *assort(struct node *s)字符串输入，运算符高低判断node *calcolate(struct node *s)表达式求值2.本程序包含四个模块：（1）主函数模块（2）链栈的构建初始化（3）表达式判断（4）表达式求值三详细设计1.元素类型、结点类型和链栈类型char string1[MAX];char string2[MAX];struct node{char data;int num;struct node *next;};2.各模块分析：（1）主函数模块void main(){struct node *top,*head;top=Initialization();printf("请输入表达式：\n");gets(string1);if(Searchexpression(string1)){head=assort(top);calcolate(head);}}（2）构造初始化链栈：struct node *Initialization() { struct node *top;top=(struct node *)malloc(sizeof(struct node));top->data='@';top->num=0;top->next=NULL;return top;}（3）输入字符串模块struct node *assort(struct node *s) {struct node *p,*top;int i;int m;char a;top=s;m=strlen(string1);for(i=0;i<=m;i++){a=string1[i];if('0'<=string1[i]&&string1[i]<='9')string2[j]=string1[i];j++;}else{switch(a){case '(':{p=(struct node *)malloc(sizeof(struct node));p->data=a;p->next=top;top=p;break;}case '*':case '/':string2[j]=' ';j++;if((top->data=='*')||(top->data=='/')){string2[j]=top->data;j++;top->data=a;break;}else{p=(struct node *)malloc(sizeof(struct node));p->data=a;p->next=top;top=p;break;}case '+':case '-':{string2[j]=' ';j++;if(top->data=='+'||top->data=='-'||top->data=='*'||top->data=='/') {string2[j]=top->data;j++;top->data=a;break;}else{p=(struct node *)malloc(sizeof(struct node));p->data=a;p->next=top;top=p;break;}}case ')':{string2[j]=' ';j++;if(top->data=='@'){printf("input error");break;}while(top->data!='('){string2[j]=top->data;j++;p=top;top=top->next;free(p);}p=top;top=top->next;free(p);break;}}}}while(top->data!='@'){string2[j]=top->data;j++;p=top;top=top->next;free(p);}string2[j]='#';printf("后缀表达式为:");for(i=0;i<j;i++)if(string2[i]!=' ')printf("%c ",string2[i]);printf("\n ");return top;}（4）表达式判断模块：int Searchexpression(char string1[]){int i1,b1,b2;int m;m=strlen(string1);if(string1[0]<'0'||string1[0]>'9'){printf("ERROR:表达式缺操作数！\n");return(WRONG);}for(i1=0;i1<=m;i1++){if(string1[i1]=='(')b1++;elseif(string1[i1]==')')b2++;}if(b1!=b2){printf("ERROR:缺少括号\n");return(WRONG);}for(i1=0;i1<m;i1++)if('0'<=string1[i1]&&string1[i1]<='9'&&'0'<=string1[i1+1]&&string1[i1+1]<=' 9'){printf("ERROR:表达式缺操作符！\n");return(WRONG);}for(i1=0;i1<=m;i1++)if(string1[i1]=='+'&&(string1[i1+1]=='+'||string1[i1+1]=='-'||string1[i1+1] =='*'||string1[i1+1]=='/')){printf("ERROR:表达式缺操作数！\n");return(WRONG);}elseif(string1[i1]=='-'&&(string1[i1+1]=='+'||string1[i1+1]=='-'||string1[i1+1] =='*'||string1[i1+1]=='/')){printf("ERROR:表达式缺操作数！\n");return(WRONG);}elseif(string1[i1]=='*'&&(string1[i1+1]=='+'||string1[i1+1]=='-'||string1[i1+1] =='*'||string1[i1+1]=='/')){printf("ERROR:表达式缺操作数！\n");return(WRONG);}elseif(string1[i1]=='/'&&(string1[i1+1]=='+'||string1[i1+1]=='-'||string1[i1+1] =='*'||string1[i1+1]=='/')){printf("ERROR:表达式缺操作数！\n");return(WRONG);}return(RIGHT);}（5）表达式求值struct node *calcolate(struct node *s){struct node *top,*p;char *q;int x,y,a;int i,n;top=s;for(i=0;i<=j;i++) {if(string2[i]>='0'&&string2[i]<='9'){q=&string2[i];a=atoi(q);for(n=i;string2[n]>='0'&&string2[n]<='9';n++){}p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;i=n-1;}elseif(string2[i]=='#')printf("计算结果为:%d\n",top->num);else{if(string2[i]==' '){}else{y=top->num;p=top;top=top->next;free(p);x=top->num;p=top;top=top->next;free(p);switch(string2[i]){case '+':{a=x+y;p=(struct node *)malloc(sizeof(struct node));p->num=a;p->next=top;top=p;break;}case '-':{a=x-y;p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;break;}case '*':{a=x*y;p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;break;}case '/':{if(y==0)printf("ERROR:除数为零!\n");a=(float)x/y;p=(struct node *)malloc(sizeof(struct node ));p->num=a;p->next=top;top=p;break;}}}}}return 0;}四使用说明、测试分析及结果1．程序使用说明（1）本程序的运行环境为VC6.0。