数据结构_实验三_栈和队列及其应用

合集下载

栈和队列的实验报告

栈和队列的实验报告栈和队列的实验报告引言：栈和队列是计算机科学中常用的数据结构，它们在算法设计和程序开发中起着重要的作用。

本实验旨在通过实际操作和观察，深入理解栈和队列的概念、特点以及它们在实际应用中的作用。

一、栈的实验1.1 栈的定义和特点栈是一种具有特殊操作约束的线性数据结构，它的特点是“先进后出”（Last-In-First-Out，LIFO）。

栈的操作包括入栈（push）和出栈（pop），入栈操作将元素放入栈顶，出栈操作将栈顶元素移除。

1.2 实验步骤在本次实验中，我们使用编程语言实现了一个栈的数据结构，并进行了以下实验步骤：1.2.1 创建一个空栈1.2.2 向栈中依次压入若干元素1.2.3 查看栈顶元素1.2.4 弹出栈顶元素1.2.5 再次查看栈顶元素1.3 实验结果通过实验，我们观察到栈的特点：最后入栈的元素最先出栈。

在实验步骤1.2.2中，我们依次压入了元素A、B和C，栈顶元素为C。

在实验步骤1.2.4中，我们弹出了栈顶元素C，此时栈顶元素变为B。

二、队列的实验2.1 队列的定义和特点队列是一种具有特殊操作约束的线性数据结构，它的特点是“先进先出”（First-In-First-Out，FIFO）。

队列的操作包括入队（enqueue）和出队（dequeue），入队操作将元素放入队尾，出队操作将队头元素移除。

2.2 实验步骤在本次实验中，我们使用编程语言实现了一个队列的数据结构，并进行了以下实验步骤：2.2.1 创建一个空队列2.2.2 向队列中依次插入若干元素2.2.3 查看队头元素2.2.4 删除队头元素2.2.5 再次查看队头元素2.3 实验结果通过实验，我们观察到队列的特点：最先入队的元素最先出队。

在实验步骤2.2.2中，我们依次插入了元素X、Y和Z，队头元素为X。

在实验步骤2.2.4中，我们删除了队头元素X，此时队头元素变为Y。

三、栈和队列的应用栈和队列在实际应用中有广泛的应用场景，下面简要介绍一些常见的应用：3.1 栈的应用3.1.1 表达式求值：通过栈可以实现对表达式的求值，如中缀表达式转换为后缀表达式，并计算结果。

数据结构实验三栈和队列的应用

第三章栈和队列的应用【实验目的】1．熟练掌握栈和队列的结构，以及这两种数据结构的特点；2．能够在两种存储结构上实现栈的基本运算，特别注意栈满和栈空的判断条件及描述方法；3．熟练掌握链队列和循环队列的基本运算，并特别注意队列满和队列空的判断条件和描述方法；第一节知识准备一、栈：1. 基本概念栈是一种限定仅在表的一端进行插入与删除操作的线性表。

允许进行插入与删除操作的这一端称为栈顶，而另一端称为栈底，不含元素的空表称为空栈，插入与删除分别称进栈与出栈。

由于插入与删除只能在同一端进行，所以较先进入栈的元素，在进行出栈操作时，要比较后才能出栈。

特别是，最先进栈者，最后才能出栈，而最晚进栈者，必最先出栈。

因此，栈也称作后进先出（Last In First Out）的线性表，简称LIFO表。

栈示意图见图3-12. 栈的抽象数据类型定义：ADT Stack{数据对象：D={ | ∈ElemSet, i=1,2,...,n, n>=0}数据关系：R1={< , >| , ∈D, i=2,...,n}基本操作：InitStack(&S) 构造一个空栈SStackEmpty(S) 判断栈S是否为空StackLength(S) 返回栈S的元素个数,即栈的长度GetTop(S,&e) 取栈S的栈顶元素Push(&S,e) 将元素e入栈Pop(&S,&e) 删除S的栈顶元素并用e返回其值（即出栈）}ADT Stack3. 栈的表示：栈有两种存储表示方法：顺序存储结构和链式存储结构。

(1)顺序存储结构：#define STACK_INIT_SIZE 100； //存储空间初始分配量#define STACKINCREMENT 10； //存储空间分配增量typedef struct{SElemType *base； //栈底指针SElemType *top； //栈顶指针int StackSize； //栈的当前容量}SqStack；(2)链式存储结构：Typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode, *LinkList;二、队列：1. 与栈相对应，队列是一种先进先出的线性表。

数据结构实验报告实验总结

数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。

通过实验，我对这些数据结构的特点、操作和应用有了更深入的了解。

下面对每一部分实验进行总结。

实验一：线性表的基本操作线性表是一种常见的数据结构，本实验要求实现线性表的基本操作，包括插入、删除、查找、遍历等。

在实验过程中，我对线性表的结构和实现方式有了更清晰的认识，掌握了用数组和链表两种方式实现线性表的方法。

实验二：栈的应用栈是一种后进先出（LIFO）的数据结构，本实验要求利用栈实现简单的括号匹配和后缀表达式计算。

通过实验，我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算，有效地解决了对应的问题。

实验三：队列的应用队列是一种先进先出（FIFO）的数据结构，本实验要求利用队列实现银行排队和迷宫求解。

通过实验，我对队列的应用有了更加深入的了解，了解到队列可以解决需要按顺序处理的问题，如排队和迷宫求解等。

实验四：链表的应用链表是一种常用的数据结构，本实验要求利用链表实现学生信息管理系统。

通过实验，我对链表的应用有了更深入的了解，了解到链表可以方便地实现对于数据的插入、删除和修改等操作，并且可以动态地调整链表的长度，适应不同的需求。

通过本次实验，我掌握了线性表、栈、队列和链表的基本操作，并了解了它们的特点和应用方式。

同时，通过实际编程的过程，我对于数据结构的实现方式和效果有了更直观的认识，也锻炼了自己的编程能力和解决问题的能力。

在实验过程中，我遇到了一些问题，如程序逻辑错误和内存泄漏等，但通过调试和修改，最终成功解决了这些问题，对自己的能力也有了更多的信心。

通过本次实验，我深刻体会到了理论与实践的结合的重要性，也对于数据结构这门课程有了更加深入的理解。

总之，本次数据结构实验给予了我很多有益的启发和收获，对于数据结构的概念、特点和应用有了更深入的理解。

在以后的学习中，我会继续加强对数据结构的学习和研究，不断提高自己的编程能力和解决问题的能力。

数据结构栈与队列的实验报告

数据结构栈与队列的实验报告实验概述本次实验的目的是通过对栈和队列进行实现和应用，加深对数据结构中的栈和队列的理解和巩固操作技能。

栈和队列作为常见的数据结构在程序开发中得到了广泛的应用，本次实验通过 C++ 语言编写程序，实现了栈和队列的基本操作，并对两种数据结构进行了应用。

实验内容1. 栈的实现栈是一种先进后出的数据结构，具有后进先出的特点。

通过使用数组来实现栈，实现入栈、出栈、输出栈顶元素和清空栈等操作。

对于入栈操作，将元素插入到数组的栈顶位置；对于出栈操作，先将数组的栈顶元素弹出，再使其下移，即将后面的元素全部向上移动一个位置；输出栈顶元素则直接输出数组的栈顶元素；清空栈则将栈中所有元素全部清除即可。

3. 栈和队列的应用利用栈和队列实现八皇后问题的求解。

八皇后问题，是指在8×8 的国际象棋盘上放置八个皇后，使得任意两个皇后都不能在同一行、同一列或者同一对角线上。

通过使用栈来保存当前八皇后的位置，逐个放置皇后并检查是否有冲突。

如果当前位置符合要求，则将位置保存到栈中，并继续查询下一个皇后的位置。

通过使用队列来进行八数码问题的求解。

八数码问题，是指在3×3 的矩阵中给出 1 至 8 的数字和一个空格，通过移动数字，最终将其变为 1 2 3 4 5 6 7 8 空的排列。

通过使用队列，从初始状态出发，枚举每种情况，利用队列进行广度遍历，逐一枚举状态转移，找到对应的状态后进行更新，周而复始直到找到正确的答案。

实验结果通过使用 C++ 语言编写程序，实现了栈和队列的基本操作，并对八皇后和八数码问题进行了求解。

程序执行结果如下：栈和队列实现的基本操作都能够正常进行，并且运行效率较高。

栈和队列的实现方便了程序编写并加速了程序运行。

2. 八皇后问题的求解通过使用栈来求解八皇后问题，可以得到一组成立的解集。

图中展示了求解某一种八皇后问题的过程。

从左到右是棋盘的列数，从上到下是棋盘的行数，通过栈的操作，求出了在棋盘上符合不同要求（不在同一行、同一列和斜线上）的八皇后位置。

数据结构实验三栈和队列的应用

数据结构实验三栈和队列的应用数据结构实验三：栈和队列的应用在计算机科学领域中，数据结构是组织和存储数据的重要方式，而栈和队列作为两种常见的数据结构，具有广泛的应用场景。

本次实验旨在深入探讨栈和队列在实际问题中的应用，加深对它们特性和操作的理解。

一、栈的应用栈是一种“后进先出”（Last In First Out，LIFO）的数据结构。

这意味着最后进入栈的元素将首先被取出。

1、表达式求值在算术表达式的求值过程中，栈发挥着重要作用。

例如，对于表达式“2 ＋ 3 4”，我们可以通过将操作数压入栈，操作符按照优先级进行处理，实现表达式的正确求值。

当遇到数字时，将其压入操作数栈；遇到操作符时，从操作数栈中弹出相应数量的操作数进行计算，将结果压回操作数栈。

最终，操作数栈中的唯一值就是表达式的结果。

2、括号匹配在程序代码中，检查括号是否匹配是常见的任务。

可以使用栈来实现。

遍历输入的字符串，当遇到左括号时，将其压入栈；当遇到右括号时，弹出栈顶元素，如果弹出的左括号与当前右括号类型匹配，则继续，否则表示括号不匹配。

3、函数调用和递归在程序执行过程中，函数的调用和递归都依赖于栈。

当调用一个函数时，当前的执行环境（包括局部变量、返回地址等）被压入栈中。

当函数返回时，从栈中弹出之前保存的环境，继续之前的执行。

递归函数的执行也是通过栈来实现的，每次递归调用都会在栈中保存当前的状态，直到递归结束，依次从栈中恢复状态。

二、队列的应用队列是一种“先进先出”（First In First Out，FIFO）的数据结构。

1、排队系统在现实生活中的各种排队场景，如银行排队、餐厅叫号等，可以用队列来模拟。

新到达的顾客加入队列尾部，服务完成的顾客从队列头部离开。

通过这种方式，保证了先来的顾客先得到服务，体现了公平性。

2、广度优先搜索在图的遍历算法中，广度优先搜索（BreadthFirst Search，BFS）常使用队列。

从起始节点开始，将其放入队列。

数据结构_实验三_栈和队列及其应用(可编辑

数据结构_实验三_栈和队列及其应用(可编辑实验三：栈和队列及其应用1.实验目的：1.1掌握栈和队列的定义与基本操作。

1.2理解栈和队列的应用场景。

1.3熟悉栈和队列在计算机程序设计中的应用。

2.实验内容：2.1实现栈数据结构的基本操作：初始化、入栈、出栈、判断栈空、判断栈满、获取栈顶元素。

2.2实现队列数据结构的基本操作：初始化、入队、出队、判断队空、判断队满、获取队头元素。

2.3利用栈实现表达式求值。

2.4 利用队列解决Josephus问题。

3.实验步骤：3.1栈的实现：栈（Stack）是一种后进先出（LIFO）的数据结构，只能在一端进行插入和删除操作。

栈的实现可以使用数组或链表，这里以数组为例。

1）初始化栈：创建一个数组，设定一个栈指针top，初始时top值为-12）入栈操作：栈不满时，将元素插入到数组的top+1位置，然后top值加13）出栈操作：栈不空时，将数组的top位置的元素删除，然后top 值减14）判断栈空：当栈指针top为-1时，表示栈空。

5）判断栈满：当栈指针top达到数组的最大索引值时，表示栈满。

6）获取栈顶元素：栈不空时，返回数组的top位置的元素。

3.2队列的实现：队列（Queue）是一种先进先出（FIFO）的数据结构，插入操作在队尾进行，删除操作在队头进行。

队列的实现可以使用数组或链表，这里以数组为例。

1）初始化队列：创建一个数组，设定两个指针front和rear，初始时front和rear值均为-12）入队操作：队列不满时，将元素插入到数组的rear+1位置，然后rear值加13）出队操作：队列不空时，将数组的front+1位置的元素删除，然后front值加14）判断队空：当front和rear指针相等且都为-1时，表示队空。

5）判断队满：当rear指针达到数组的最大索引值时，表示队满。

6）获取队头元素：队列不空时，返回数组的front+1位置的元素。

3.3表达式求值：使用栈可以实现对表达式的求值。

实验三栈和队列的应用

实验三栈和队列的应用第一篇：实验三栈和队列的应用一、实验目的掌握栈的数据类型描述及栈的特点；掌握栈的顺序存储结构的特点及算法描述；掌握队列的数据类型描述及链式存储结构的特点和算法描述。

二、实验内容停车场管理。

设有一个可以停放n辆汽车的狭长停车场（先进后出），它只有一个大门可以供车辆进出。

车辆按到达停车场时间的先后依次从停车场最里面向大95E8口处停放（最先到达的第一辆车停放在停车场的最里面）。

如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车离开，则排在便道上的第一辆车就可以进入停车场。

停车场内如有某辆车要离开，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车再按原来的次序进停车场。

每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。

如果停留在便道上的车没进停车场就要离开，允许其离开，不收停车费，并且仍然保持在便道上的车辆次序。

试编程模拟停车场管理。

三、算法描述提示：可以将停车场定义成一个顺序栈s1，便道定义成一个链队列q，而停车场中的某辆车要离开，则在它后面进停车场的车必须让道，让其离开，故还必须有一个临时的顺序栈s2，存放让道的车辆。

当有车辆进停车场时，直接进入s1栈，若s1栈满，则进入便道（链队列q）。

若有s1中车辆x离开时，先让在x后面进栈的车从s1退栈并进栈到s2中，让x离开并收取停车费，然后，再把s2中的所有车辆退栈并重新进入s1栈，最后，将链队列q的队头车辆进栈到s1中并删除队头车辆。

若有链队列q（便道）中的车辆y离开时，从链队列中删除该车辆即可，不收停车费。

车辆的数据可以表示为（车辆编号，到达/离开时间）。

四.程序清单: #include using namespace std;const intStackSize=5;class SeqStack { public:SeqStack(){top=-1;} ~SeqStack(){};void Push(int x);void Push2(int x);int *Return();int Pop(int y);int Count();void PrintStack();private: int data[StackSize];int top;};//入栈void SeqStack::Push(int x){ if(top>=StackSize-1)throw“上溢”;for(int i=0;i<=top+1;i++){if(data[i]==x){cout<<“该车牌已经存在!请重新输入: ”;i=-1;cin>>x;} } top++;data[top]=x;} //返回数组地址int *SeqStack::Return(){ return data;} //临时栈void SeqStack::Push2(int x){ top++;data[top]=x;} //输出函数void SeqStack::PrintStack(){ for(int i=0;i<=top;i++)cout<<“位置为”<int SeqStack::Pop(int y){ if(top==-1)throw“下溢”;int x;x=data[top--];if(y==top+2)data[top+1]=123456789;if(top==-1)data[top+1]=123456789;return x;} //数数int SeqStack::Count(){ return top;}//队列struct Node { int data;Node *next;};class LinkQueue { public: LinkQueue();void EnQueue(int x,int *q);void xzDeQueue(int x);int Count();int DeQueue();private: Node *front,*rear;};//构造函数LinkQueue::LinkQueue(){ Node *s=new Node;s->next=NULL;front=rear=s;} //入队void LinkQueue::EnQueue(int x,int *q){ Node *s=new Node;Node *p=new Node;p=front;while(p){if(p->data ==x){cout<<“便道已有该车牌号,请重新输入: ”;cin>>x;for(int i=0;i<5;i++){if(x==q[i]){cout<<“停车场已有该车牌号,请重新输入: ”;cin>>x;i=-1;}}p=front;} p=p->next;} s->data =x;s->next =NULL;rear->next =s;rear=s;} //出队int LinkQueue::DeQueue(){ if(front==rear)throw“便道无车辆”;Node *p=new Node;int x;p=front->next;x=p->data;front->next =p->next;if(p->next ==NULL)rear=front;delete p;return x;} //计算结点数int LinkQueue::Count(){ Node *p=new Node;p=front;int i=0;while(p&&p->next!=NULL){p=p->next;i++;} return i;} //选择性出队void LinkQueue::xzDeQueue(int x){ if(rear==front)throw“便道无车辆”;Node *p=new Node;p=front;int y;int i=0;for(;p->next!=NULL;p=p->next){if(p->next->data ==x)if(p->next->next!=NULL){Node *q=new Node;q=p->next;y=q->data;p->next =q->next;i=1;delete q;cout<<“车牌号为:”<break;}else{Node *q=new Node;q=p->next;y=q->data;p->next =NULL;i=1;delete q;if(front->next==NULL)rear=front;cout<<“车牌号为:”<break;}} if(i==0)cout<<“无车牌号为:”< SeqStack b;//b是作为临时存放车辆的栈LinkQueue c;//c是作为便道的队列cout<<“tttt1.车辆进入”<cout<<“tttt4.便道车辆离开”<int xh1=1;//xh1为菜单最外层的循环控制变量int time[100];//记录各车辆进入停车场的时间int t1=0;//作为车辆对应的时间编号int money=1;while(xh1==1){cout<<“请选择指令: ”;cin>>zl;switch(zl){case 1:try{int n1=a.Count();int n;cout<<“请输入车牌号: ”;cin>>n;if(n1==4){int *Num=a.Return();for(int i=0;i<=4;i++)if(Num[i]==n){cout<<“停车场已有该车牌号,请重新输入!”; cin>>n;i=-1;}int *CarNum=a.Return();c.EnQueue(n,CarNum);cout<<“停车场已满,请在便道等候!”< break;}a.Push(n);cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”; cin>>time[t1];}t1++;}catch(char*s){cout<break;case 2:try{int n2;//离开车辆的编号cout<<“请输入要离开的车的位置: ”; cin>>n2;if(a.Count()+1==0){cout<<“该停车场没有车辆,请选择其他操作!”; break;}elsewhile(n2<1||n2>a.Count()+1){cout<<“请输入1~”<cin>>n2;}int j=a.Count();for(int i=0;i<(j+1-n2);i++)b.Push2(a.Pop(n2));a.Pop(n2);int j2=b.Count();for(int i1=0;i1<=j2;i1++)a.Push(b.Pop(n2));int j3=c.Count();int time1;cout<<“请输入离开时间: ”;cin>>time1;while(time1<0||time1>23){cout<<“请输入正确的时间(0~23时): ”;cin>>time1;}int day=0;if(time1{cout<<“离开时间已小于进入时间!请加上停留天数(天):”;cin>>day;while(day<=0){cout<<“输入的天数必须大于0：”;cin>>day;}}cout<<“您的费用是(元): ”<<(time1-time[n2-1]+24*day)*money<for(int i2=0;i2<(j+1-n2);i2++)time[n2-1+i2]=time[n2+i2];t1--;if(j3!=0){a.Push(c.DeQueue());cout<<“ttt通知: 便道车辆请进入停车场!”<cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”;cin>>time[t1];}t1++;}}catch(char *s){cout<break;case 3:a.PrintStack();break;case 4:int n3;cout<<“请输入离开车辆的车牌号: ”;cin>>n3;try{c.xzDeQueue(n3);}catch(char*s){cout<break;case 5:cout<<“请输入单价: ”;cin>>money;cout<<“修改成功!”<cout<<“当前停车场的费用是:”<break;case 6:xh1=0;break;} } system(“pause”);}心得体会:完成时间:2010-10-30第二篇：实验三栈和队列实验报告三栈和队列班级：姓名：学号：专业：一、实验目的：（1）掌握栈的基本操作的实现方法。

数据结构实验-线性表及其实现栈和队列及其应用

数据结构实验报告一实验名称:线性表及其实现栈和队列及其应用1 实验目的及实验要求1.线性表目的要求：（1）熟悉线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现，以线性表的各种操作（建立、插入、删除等）的实现为实验重点；（2）通过本次实验帮助学生加深对顺序表、链表的理解，并加以应用；（3）掌握循环链表和双链表的定义和构造方法2.栈和队列目的要求：（1）掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们；（2）本实验训练的要点是“栈”的观点及其典型用法；（3）掌握问题求解的状态表示及其递归算法，以及由递归程序到非递归程序的转化方法。

2实验内容及实验步骤（附运行结果截屏）1.线性表实验内容：（1）编程实现线性表两种存储结构（顺序存储、链式存储）中的基本操作的实现（线性表的创建、插入、删除和查找等），并设计一个菜单调用线性表的基本操作。

（2）建立一个按元素递增有序的单链表L，并编写程序实现：a）将x插入其中后仍保持L的有序性；b）将数据值介于min和max之间的结点删除，并保持L的有序性；c）（选做）将单链表L逆置并输出；（3）编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。

注：（1）为必做题，（2）~（3）选做。

2.栈和队列实验内容：（1）编程实现栈在两种存储结构中的基本操作（栈的初始化、判栈空、入栈、出栈等）；（2）应用栈的基本操作，实现数制转换（任意进制）；（3）编程实现队列在两种存储结构中的基本操作（队列的初始化、判队列空、入队列、出队列）；（4）利用栈实现任一个表达式中的语法检查（括号的匹配）。

（5）利用栈实现表达式的求值。

注：（1）～（2）必做，（3）～（5）选做。

实验步骤：先编写线性表和栈和队列的类模板，实现各自的基础结构，之后按照要求编写适当的函数方法（公共接口），最后完成封装。

编写主函数直接调用即可。

核心代码：//LinearList.h 顺序表//类的声明1.template<class T>2.class LinearList3.{4.public:5.LinearList(int sz = default_size);6.~LinearList();7.int Length()const; //length of the linear8.int Search(T x)const; //search x in the linear and return its order number9.T GetData(int i)const; //get i th order's data10.bool SetData(int i,T x); //change i th order's data to x11.bool DeleteData(int i);12.bool InsertData(int i,T x);13.void output(bool a,int b,int c); //print the linear14.void ReSize(int new_size);15.16.private:17.T *data;18.int max_size,last_data;19.};//构造函数1.template<class T>2.LinearList<T>::LinearList(int sz)3.{4.if(sz>0)5.{6.max_size = sz;st_data=-1;8.data=new T[max_size];9.if(data == NULL)10.{11.cerr<<"Memory creat error!"<<endl;12.exit(1);13.}14.}15.else16.{17.cerr<<"Size error!"<<endl;18.exit(1);19.}20.}//Qlist.h 链式表//模板类的声明1.template<class T>2.struct LinkNode3.{4.T data;5.LinkNode<T> *link;6.LinkNode(LinkNode<T> *ptr = NULL)7.{8.link = ptr;9.}10.LinkNode(const T item,LinkNode<T> *ptr = NULL)11.{12.data = item;13.link = ptr;14.}15.};16.17.template<class T>18.class Qlist: public LinkNode<T>19.{20.public:21.Qlist();22.Qlist(const T x);23.Qlist(Qlist<T>&L);24.~Qlist();25.void MakeEmpty();26.int Length()const; //length of the linear27.int Search(T x)const; //search x in the linear and return its order number28.LinkNode<T> *Locate(int i);29.T GetData(int i); //get i th order's data30.bool SetData(int i,T x); //change i th order's data to x31.bool DeleteData(int i);32.bool InsertData(int i,T x);33.void output(bool a,int b,int c); //print the linear34.35.protected:36.LinkNode<T> *first;37.};//构造函数1.template<class T>2.Qlist<T>::Qlist(Qlist<T>&L)3.{4.T value;5.LinkNode<T>*src = L.getHead();6.LinkNode<T>*des = first = new LinkNode<T>;7.while(src->link != NULL)8.{9.value = src->link->data;10.des->link = new LinkNode<T>(value);11.des = des->link;12.src = src->link;13.}14.des->link = NULL;15.}截屏：3 实验体会（实验遇到的问题及解决方法）刚开始的时候本想先写线性表的类模板然后分别进行继承写顺序表和链式表甚至是以后的栈和队列。

实验报告——栈和队列的应用

实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求：（1）熟练栈和队列的基本操作；（2）能够利用栈与队列进行简单的应用。

一、题目题目1.利用顺序栈和队列，实现一个栈和一个队列，并利用其判断一个字符串是否是回文。

所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。

例如，a+b&b+a等等。

题目2.假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。

跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。

若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。

现要求写一算法模拟上述舞伴配对问题，并实现。

题目3.打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。

每台打印机具有一个队列（缓冲池），用户提交打印请求被写入到队列尾，当打印机空闲时，系统读取队列中第一个请求，打印并删除之。

请利用队列的先进先出特性，完成打印机网络共享的先来先服务功能。

题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。

试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。

题目5.利用循环链队列求解约瑟夫环问题。

请大家从本组未讨论过的五道题中选择一道，参照清华邓俊辉老师MOOC视频及课本相关知识，编写相应程序。

选择题目3：打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。

二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x）{//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空，新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空，在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令，即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数，将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空，为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。

《算法与数据结构》实验报告实验3--栈与队列的应用

《算法与数据结构》实验报告姓名学号专业班级计算机类1301实验3栈与队列的应用指导教师实验名称实验目的●了解并掌握栈与队列的概念与定义●能够实现并运用栈与队列●熟练运用栈与队列的基本操作●使用栈实现回溯算法实验环境●个人计算机一台，CPU主频1GHz以上，1GB以上内存，2GB以上硬盘剩余空间。

●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本，英文版)，或VC++ 6.0实验内容1 基本部分(必做)1．链式栈的创建与操作设链式栈中元素的数据类型为整型，编写函数实现以下操作：（1）链式栈的初始化（2）链式栈的输出（从栈顶到栈底）（3）链式栈的判空操作（4）链式栈入栈操作（5）链式栈的出栈操作（6）取栈顶元素的值注：链式栈可不带头节点源代码：ds6.c 2．循环队列的创建与操作设循环队列中元素的数据类型为整型，编写函数实现以下操作：（1）循环队列的初始化（2）循环队列的入栈（3）循环队列的出栈（4）取循环队列的栈顶元素（5）循环队列的输出（从栈顶到栈底）源代码：ds7.c 3．符号平衡问题在语言中往往需要判断一些符号是否是成对出现的，比如{}、[]、()。

如何让判断符号的对称也是很多语言的语法检查的首要任务。

设计一个函数来检查表达式中的符号()、[]、{}是否平衡。

若平衡，返回1；若不平衡返回0。

例如：a(dda){[dfsafd[dfsd]](((fdsd)dfd))dfd}是符号平衡的。

{ad[x(df)ds)]}不是符号平衡的。

源代码：ds8.c实验代码：1.#include<stdio.h>#define MAXSIZE maxlentypedef int elemtype;typedef struct stacknode{elemtype data;struct stacknode *next;}StackNode;typedef struct{StackNode *top;}LinkStack;int *InitStack(LinkStack *S);//初始化链式栈int *Push(LinkStack *S);//入栈函数int *view(LinkStack *S);//输出函数int *Pop(LinkStack *S);//出栈函数int StackTop(LinkStack *S);//取栈顶函数main(){LinkStack *S;int a;char k;S=InitStack(S);if(S->top==NULL){printf("该链式栈为空！");}Push(S);printf("按任意键开始出栈！");getchar();getchar();Pop(S);a=StackTop(S);printf("栈顶元素为%d",a);printf("程序运行完毕,是否重新运行（y/n）：");scanf("%s",&k);if(k=='y'){main();}}int *InitStack(LinkStack *S){S=(LinkStack*)malloc(sizeof(LinkStack));S->top=NULL;return(S);}int *Push(LinkStack *S){int n,i,item;StackNode *p;printf("请输入即将入栈的数据个数：");scanf("%d",&n);for(i=0;i<n;i++){printf("请输入第%d个数：",i+1);scanf("%d",&item);p=(LinkStack*)malloc(sizeof(StackNode));p->data=item;p->next=NULL;p->next=S->top;S->top=p;}view(S);return(S);}int *view(LinkStack *S){StackNode *p;if(S->top==NULL){printf("链式栈为空！");return(0);}else printf("该链式栈从栈顶到栈底数据如下：\n");for(p=S->top;p!=NULL;p=p->next){printf("%d\n",p->data);}}int *Pop(LinkStack *S){StackNode *p;int item;char k;p=S->top;if(S->top==NULL){printf("链式栈为空！");return(0);}else{item=p->data;printf("出栈数据为%d\n",item);S->top=p->next;free(p);view(S);}printf("是否继续出栈（y/n）：");scanf("%s",&k);if(k=='y'){Pop(S);}else return(S);}int StackTop(LinkStack *S){if(S->top==NULL){printf("该链式栈为空！");}return(S->top->data);}2.#include<stdio.h>#define MAXSIZE 30typedef int elemtype;typedef struct{elemtype data[MAXSIZE];int front,rear;}seqqueue;int a=0;//全局变量int InitQueue(seqqueue *Q);//初始化队列函数int view(seqqueue *Q);//输出函数int EnQueue(seqqueue *Q);//入队函数int DeQueue(seqqueue *Q);//出队函数main(){seqqueue *Q;Q=InitQueue(Q);if(Q->front==Q->rear){printf("该队列为空！");}EnQueue(Q);printf("按任意键开始出栈！");getchar();getchar();DeQueue(Q);printf("程序运行完毕,是否重新运行（y/n）："); }int InitQueue(seqqueue *Q){Q=(seqqueue*)malloc(sizeof(seqqueue));Q->front=Q->rear=0;return(Q);}int EnQueue(seqqueue *Q){int n,i,item;printf("请输入即将入队的数据个数：");scanf("%d",&n);if(a>MAXSIZE){printf("该队列已满！");return(0);}else for(i=0;i<n&&a<=30;i++){printf("请输入第%d个数：",i+1);scanf("%d",&item);Q->data[Q->rear]=item;Q->rear=(Q->rear+1)%MAXSIZE;a++;}view(Q);return(Q);}int view(seqqueue *Q){seqqueue *r;int i,j;if(a==0){printf("该队列为空！");return(0);}else printf("该队列从栈顶到栈底数据如下：\n");for(i=0,j=Q->front;i<a;i++,j=(j+1)%MAXSIZE){printf("%d\n",Q->data[j]);}return(Q);}int DeQueue(seqqueue *Q){elemtype item;char k;if(a==0){printf("该队列为空！");return(0);}else{item=Q->data[Q->front];Q->front=(Q->front+1)%MAXSIZE;printf("出队数据为%d\n",item);a--;view(Q);}printf("是否继续出栈（y/n）：");scanf("%s",&k);if(k=='y'){DeQueue(Q);}else return(Q);}3·#include "stdio.h"#include "stdlib.h"#define MAXSIZE 100typedef struct{char data[MAXSIZE];int top;} stack;stack *InitStack(stack *s){s=(stack *)malloc(sizeof(stack));s->top=-1;return s;}int f(stack *s){int i=0,flag=1;char str[MAXSIZE];printf("请输入表达式：");scanf("%s",str);for(i=0;str[i]!='\0';i++){if(str[i]=='('||str[i]=='['||str[i]=='{'){s->top++;s->data[s->top]=str[i];}if(str[i]==')'||str[i]==']'||str[i]=='}'){if(s->top>=0){if(s->data[s->top]==str[i]) s->top--;else{flag=0;break;}}else{flag=0;break;}}}if(s->top!=-1)flag=0;return flag;}int main(){int n;stack *s;s=InitStack(s);n=f(s);if(n==1) printf("表达式中符号平衡\n");else printf("表达式中符号0平衡\n");}使用以上操作，即可完成题目要求。

栈和队列的应用实验报告

栈和队列的应用实验报告栈和队列的应用实验报告引言：栈和队列是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。

本实验报告旨在探讨栈和队列的基本概念、特性以及它们在实际应用中的具体使用。

一、栈的基本概念和特性栈是一种特殊的数据结构，它遵循“先进后出”的原则。

栈有两个基本操作：压栈（push）和弹栈（pop）。

压栈将元素添加到栈的顶部，弹栈则将栈顶元素移除。

栈还具有一个重要的特性，即它的访问方式是受限的，只能访问栈顶元素。

在实际应用中，栈可以用于实现递归算法、表达式求值、括号匹配等。

例如，在递归算法中，当函数调用自身时，需要将当前状态保存到栈中，以便在递归结束后能够恢复到正确的状态。

另外，栈还可以用于实现浏览器的“后退”功能，每次浏览新页面时，将当前页面的URL压入栈中，当用户点击“后退”按钮时，再从栈中弹出最近访问的URL。

二、队列的基本概念和特性队列是另一种常见的数据结构，它遵循“先进先出”的原则。

队列有两个基本操作：入队（enqueue）和出队（dequeue）。

入队将元素添加到队列的尾部，出队则将队列头部的元素移除。

与栈不同的是，队列可以访问头部和尾部的元素。

在实际应用中，队列经常用于任务调度、消息传递等场景。

例如，在操作系统中，任务调度器使用队列来管理待执行的任务，每当一个任务执行完毕后，从队列中取出下一个任务进行执行。

另外，消息队列也是一种常见的应用，它用于在分布式系统中传递消息，保证消息的顺序性和可靠性。

三、栈和队列在实际应用中的具体使用1. 栈的应用栈在计算机科学中有广泛的应用。

其中一个典型的应用是表达式求值。

当计算机遇到一个复杂的表达式时，需要将其转化为逆波兰表达式，然后使用栈来进行求值。

栈的特性使得它非常适合处理这种情况，可以方便地保存运算符和操作数的顺序，并按照正确的顺序进行计算。

另一个常见的应用是括号匹配。

在编程语言中，括号是一种常见的语法结构，需要保证括号的匹配性。

数据结构_实验三_栈和队列及其应用

数据结构_实验三_栈和队列及其应用实验编号:3 四川师大《数据结构》实验报告 2016年10月29日实验三栈和队列及其应用_一(实验目的及要求(1) 掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们;(2) 本实验训练的要点是“栈”的观点及其典型用法;(3) 掌握问题求解的状态表示及其递归算法，以及由递归程序到非递归程序的转化方法。

二(实验内容(1) 编程实现栈在两种存储结构中的基本操作(栈的初始化、判栈空、入栈、出栈等);(2) 应用栈的基本操作，实现数制转换(任意进制);(3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);(4) 利用栈实现任一个表达式中的语法检查(括号的匹配)。

(5) 利用栈实现表达式的求值。

注:(1),(3)必做，(4),(5)选做。

三(主要仪器设备及软件(1) PC机(2) Dev C++ ,Visual C++, VS2010等四(实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写，请另加附页)(1) 编程实现栈在两种存储结构中的基本操作(栈的初始化、判栈空、入栈、出栈等);A.顺序储存:, 代码部分://Main.cpp:#include"SStack.h"int main(){SqStack S;SElemType e;int elect=1;InitStack(S);cout << "已经创建一个存放字符型的栈" << endl;while (elect){Muse();cin >> elect;cout << endl;switch (elect){case 1:cout << "input data:";cin >> e;Push(S, e);break;case 2:if(Pop(S, e)){cout << e <<" is pop"<< endl; } else{cout<<"blank"<<endl;} break;case 3:if (StackEmpty(S)){cout << "栈空 " << endl;}else{cout << "栈未空 " << endl;}break;case 4:GetTop(S, e);cout << "e is " << e << endl;break;case 5:StackLength(S);break;case 0:break;}}DestroyStack(S);return OK;}//SStack.cpp:#include"SStack.h"//输出菜单void Muse(){cout << "请选择功能:" << endl;cout << " 1.入栈" << endl;cout << " 2.出栈" << endl;cout << " 3.判栈空" << endl;cout << " 4.返回栈顶部数据" << endl; cout << " 5.栈长" << endl;cout << " 0.退出系统" << endl;cout << "你的选择是:" ;}//创建栈Status InitStack(SqStack &S) {S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType)); if (!S.base) exit(ERROR);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//得到顶部数据Status GetTop(SqStack S, SElemType &e) {if (S.base == S.top) return ERROR;e = *(S.top - 1);return OK;}//入栈Status Push(SqStack &S, SElemType &e) {if (S.top - S.base >= STACK_INIT_SIZE){S.base = (SElemType *)realloc(S.base, (STACK_INIT_SIZE + STACKINCREMENT) * sizeof(SElemType));if (!S.base) exit(ERROR);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}//出栈Status Pop(SqStack &S, SElemType &e) { if (S.base == S.top){return ERROR;}e = *--S.top;cout<<"pop succeed"<<endl;return OK;}//判栈空Status StackEmpty(SqStack S) {if (S.top == S.base){return ERROR;}return OK;}//销毁栈Status DestroyStack(SqStack &S){free(S.base);S.top=NULL;S.stacksize = 0;cout << "栈已销毁" << endl;return OK;}int StackLength(SqStack S) {cout << "StackLength is "<<S.top-S.base << endl;return OK;}//SStack.h:#include<iostream> #include<stdlib.h> using namespace std;const int STACK_INIT_SIZE = 100;const int STACKINCREMENT = 10;const int ERROR = 0; const int OK = 1;typedef char SElemType; typedef int Status; typedef struct {SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack(SqStack &S);//创建顺序存储的栈 StatusGetTop(SqStack S, SElemType &e);//得到栈顶数据 Status Push(SqStack &S, SElemType &e);//入栈 Status Pop(SqStack &S, SElemType &e);//出栈 void Muse();//输出菜单界面Status StackEmpty(SqStack S);//判断栈是否为空 StatusDestroyStack(SqStack &S);//销毁栈 int StackLength(SqStack S);//计算栈的长度, 运行结果:B. 链式储存:, 代码部分://Main.cpp#include"Lstack.h" int main(){Lq_Stack L;if(InintStack (L)){cout<<"build stack succeed"<<endl;}else exit (ERROR);int e=0;Menu(L,e);DestroyStack(L);return 0;}//Lstack.cpp#include"Lstack.h" Status InintStack(Lq_Stack &L){ //创建栈L=(LqStack *)malloc(sizeof(LqStack));if(!L) exit(ERROR);L->data=0;L->next=NULL;return OK;}Status push (Lq_Stack &L,SElemType e){//入栈LqStack *p;p=(LqStack *)malloc(sizeof(LqStack));if(!p) exit(ERROR);p->data=e;L->data++;p->next=L->next;L->next=p;return OK;}Status pop (Lq_Stack &L,SElemType &e){ //出栈LqStack *p;if(L->next==NULL) return ERROR;p=L->next;e=p->data;L->next=p->next;L->data--;free(p);return OK;}Status GetTop(Lq_Stack L, SElemType &e){ //得到栈顶数据if(L->next==NULL) return ERROR;e=L->next->data;return OK;}Status StackEmpty(Lq_Stack L){//判断栈是否为空if(L->next==NULL){return ERROR;}else return OK;}int StackLength(Lq_Stack L){//计算栈的长度return L->data;}Status DestroyStack(Lq_Stack &L){//销毁栈LqStack *p;while(!L){L=p;L=L->next;free(p);}return OK;}void Menu(Lq_Stack &L,SElemType e){//输出菜单选择执行的功能int select=1;while(select){cout<<"————————————"<<endl; cout<<"请选择功能"<<endl;cout<<"——————1.入栈"<<endl;cout<<"——————2.出栈"<<endl;cout<<"——————3.得到顶部数据"<<endl;cout<<"——————4.判断栈是否为空"<<endl; cout<<"——————5.输出栈的长度"<<endl; cout<<"——————0.退出程序"<<endl;cout<<"你的选择是:";cin>>select;switch (select){case 0:break;case 1:cout<<"push data:";cin>>e;if(push(L,e)){cout<<"push succeed"<<endl;}else cout<<"push failed"<<endl;break;case 2:if(pop(L,e)){cout<<"data "<<e<<" is pop"<<endl;}else cout<<"pop failed"<<endl;break;case 3:if(GetTop(L,e)){cout<<"head data "<<e<<" is pop"<<endl;} else cout<<"Get failed"<<endl;break;case 4:if(StackEmpty(L)){cout<<"stack is not NULL"<<endl;}else cout<<"stack is NULL"<<endl;break;case 5:cout<<"this stack length is "<<StackLength(L)<<endl;break;}}}//Lstack.h#include<iostream>#include<stdlib.h>using namespace std; const int OK=1;const int ERROR=0;typedef int SElemType; typedef int Status; typedef struct LqStack{ SElemType data;struct LqStack *next; }LqStack,*Lq_Stack;Status InintStack (Lq_Stack &L);//创建栈Status push (Lq_Stack &L,SElemType e);//入栈 Status pop (Lq_Stack&L,SElemType &e);//出栈 Status GetTop(Lq_Stack L, SElemType &e);//得到栈顶数据 Status StackEmpty(Lq_Stack L);//判断栈是否为空int StackLength(Lq_Stack L);//计算栈的长度Status DestroyStack(Lq_Stack &L);//销毁栈void Menu(Lq_Stack &L,SElemType e);//输出菜单选择执行的功能, 运行结果:(2) 应用栈的基本操作，实现数制转换(任意进制);; , 代码部分: //Main.cpp#include"SStack.h"int main(){int number;cout<<"要将数值转换为多少进制 ";cin>>number;conversion(number);return 0;}SStack.cpp#include"SStack.h"Status InitStack(SStack &S){//创建栈S.dase=(ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType)); if (!S.dase) exit(ERROR);S.top=S.dase;S.stacksize=STACK_INIT_SIZE;return OK;}Status push(SStack &S,ElemType e){//入栈if(S.top-S.dase >= S.stacksize){//栈满追加空间S.dase=(ElemType *)realloc(S.dase,(STACK_INIT_SIZE+STACKINCREMENT) * sizeof(ElemType));if(!S.dase) exit(ERROR);S.top=S.dase+STACK_INIT_SIZE;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status pop(SStack &S,ElemType &e){//出栈if(S.top== S.dase) return ERROR; e=*--S.top;return OK;}Status StackEmpty(SStack &S){//判断栈是否为空if(S.dase==S.top) return ERROR; return OK;}void conversion(int number){//转换为e进制并输出SStack S;int N,e;if(InitStack(S)){cout<<"栈创建成功"<<endl;}cout<<"输入待转换的数:";cin>>N;while(N){push(S,N%number);N=N/number;}while(StackEmpty(S)){pop(S,e);cout<<e;}cout<<endl;}//SStack.h#ifndef SSTACK_H#define SSTACK_H#include<iostream> #include<stdlib.h> using namespace std;const int STACK_INIT_SIZE=100;const int STACKINCREMENT=10;const int OK=1;const int ERROR=0;typedef int Status; typedef int ElemType; typedef struct {ElemType *dase;ElemType *top;int stacksize;}SStack;Status InitStack(SStack &S);//创建栈Status push(SStack &S,ElemType e);//入栈 Status push(SStack&S,ElemType &e);//出栈 Status StackEmpty(SStack &S);//判断栈是否为空void conversion(int number);//转换为number进制并输出#endif, 运行结果:(3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列)。

数据结构_实验三_栈和队列及其应用

return OK;
}
//SStack、h:
#include<iostream>
#include<stdlib、h>
using namespace std;
const int STACK_INIT_SIZE = 100;
const int STACKINCREMENT = 10;
const int ERROR = 0;
S、top = S、base + S、stacksize;
S、stacksize += STACKINCREMENT;
}
*S、top++ = e;
return OK;
}
//出栈
Status Pop(SqStack &S, SElemType &e)
{
if (S、base == S、top)
{
return ERROR;
return OK;
}
//得到顶部数据
Status GetTop(SqStack S, SElemType &e)
{
if (S、base == S、top) return ERROR;
e = *(S、top - 1);
return OK;
}
//入栈
Status Push(SqStack &S, SElemType &e)
二．实验内容
（1）编程实现栈在两种存储结构中的基本操作(栈的初始化、判栈空、入栈、出栈等);
（2）应用栈的基本操作,实现数制转换(任意进制);
（3）编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);

数据结构课程实验报告

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

在数据结构课程中，我们学习了各种数据结构的原理和应用，并通过实验来加深对这些概念的理解。

本文将对我在数据结构课程中的实验进行总结和分析。

实验一：线性表的实现与应用在这个实验中，我们学习了线性表这种基本的数据结构，并实现了线性表的顺序存储和链式存储两种方式。

通过实验，我深刻理解了线性表的插入、删除和查找等操作的实现原理，并掌握了如何根据具体应用场景选择合适的存储方式。

实验二：栈和队列的实现与应用栈和队列是两种常见的数据结构，它们分别具有后进先出和先进先出的特点。

在这个实验中，我们通过实现栈和队列的操作，加深了对它们的理解。

同时，我们还学习了如何利用栈和队列解决实际问题，比如迷宫求解和中缀表达式转后缀表达式等。

实验三：树的实现与应用树是一种重要的非线性数据结构，它具有层次结构和递归定义的特点。

在这个实验中，我们学习了二叉树和二叉搜索树的实现和应用。

通过实验，我掌握了二叉树的遍历方法，了解了二叉搜索树的特性，并学会了如何利用二叉搜索树实现排序算法。

实验四：图的实现与应用图是一种复杂的非线性数据结构，它由节点和边组成，用于表示事物之间的关系。

在这个实验中，我们学习了图的邻接矩阵和邻接表两种存储方式，并实现了图的深度优先搜索和广度优先搜索算法。

通过实验，我深入理解了图的遍历方法和最短路径算法，并学会了如何利用图解决实际问题，比如社交网络分析和地图导航等。

实验五：排序算法的实现与比较排序算法是数据结构中非常重要的一部分，它用于将一组无序的数据按照某种规则进行排列。

在这个实验中，我们实现了常见的排序算法，比如冒泡排序、插入排序、选择排序和快速排序等，并通过实验比较了它们的性能差异。

通过实验，我深入理解了排序算法的原理和实现细节，并了解了如何根据具体情况选择合适的排序算法。

结论：通过这些实验，我对数据结构的原理和应用有了更深入的理解。

数据结构栈和队列的基本操作及应用实验报告

实验日期2010.4.26 教师签字成绩实验报告【实验名称】第三章栈和队列的基本操作及应用【实验目的】（1）熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现；（2）熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。

【实验内容】1.链栈的基本操作（链栈的初始化、进栈、出栈以及取栈顶的值）#include "stdio.h"#include "malloc.h"#include "stdlib.h"typedef int Elemtype;typedef struct stacknode {Elemtype data;stacknode * next;}StackNode;typedef struct {stacknode * top; //栈顶指针}LinkStack;/*初始化链栈*/void InitStack(LinkStack * s){ s->top=NULL;printf("\n已经初始化链栈！\n");}/*链栈置空*/void setEmpty(LinkStack * s){ s->top=NULL;printf("\n链栈被置空！\n");}/*入栈*/void pushLstack(LinkStack * s, Elemtype x){ StackNode * p;p=(StackNode *)malloc(sizeof(StackNode)); //建立一个节点。

p->data=x;p->next=s->top; //由于是在栈顶pushLstack，所以要指向栈顶。

s->top=p; //插入}/*出栈*/Elemtype popLstack(LinkStack * s){ Elemtype x;StackNode * p;p=s->top; //指向栈顶if (s->top ==0){ printf("\n栈空，不能出栈！\n");exit(-1);}x=p->data;s->top=p->next; //当前的栈顶指向原栈的nextfree(p); //释放return x;}/*取栈顶元素*/Elemtype StackTop(LinkStack *s){ if (s->top ==0){ printf("\n链栈空\n");exit(-1);}return s->top->data;}/*遍历链栈*/void Disp(LinkStack * s){ printf("\n链栈中的数据为：\n");printf("=======================================\n");StackNode * p;p=s->top;while (p!=NULL){ printf("%d\n",p->data);p=p->next;}printf("=======================================\n");}void main(){ printf("================= 链栈操作=================\n\n");int i,m,n,a;LinkStack * s;s=(LinkStack *)malloc(sizeof(LinkStack));int cord;do{ printf("\n");printf("第一次使用必须初始化！\n");printf("\n");printf("\n 主菜单\n");printf("\n 1 初始化链栈\n");printf("\n 2 入栈\n");printf("\n 3 出栈\n");printf("\n 4 取栈顶元素\n");printf("\n 5 置空链栈\n");printf("\n 6 结束程序运行\n");printf("\n--------------------------------\n");printf("请输入您的选择( 1, 2, 3, 4, 5,6)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:{ InitStack(s);Disp(s);}break;case 2:{printf("输入将要压入链栈的数据的个数：n=");scanf("%d",&n);printf("依次将%d个数据压入链栈：\n",n);for(i=1;i<=n;i++){scanf("%d",&a);pushLstack(s,a);}Disp(s);}break;case 3:{ printf("\n出栈操作开始!\n");printf("输入将要出栈的数据个数：m=");scanf("%d",&m);for(i=1;i<=m;i++){printf("\n第%d次出栈的数据是：%d",i,popLstack(s));}Disp(s);}break;case 4:{ printf("\n\n链栈的栈顶元素为：%d\n",StackTop(s));printf("\n");}break;case 5:{ setEmpty(s);Disp(s);}break;case 6:exit(0);}}while (cord<=6);}2.顺序栈的基本操作（顺序栈的初始化、进栈、出栈以及取栈顶的值）#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define STACKSIZE 100#define STACKINCREMENT 10#define null 0typedef struct {int *base;int *top;int stacksize;}SqStack;SqStack Initstack(){SqStack S;S.base=(int *)malloc(STACKSIZE*sizeof(int));if(!S.base){printf("\n存储分配失败\n");exit(0);}S.top=S.base;S.stacksize=STACKSIZE;return S;}int StackEmpty(SqStack S){if(S.top==S.base) return 1;else return 0;}int StackLength(SqStack S){int *p;p=S.base;for(int i=0;p!=S.top;p++,i++);return i;}int GetTop(SqStack S){int e;if(StackEmpty(S)) {printf("当前栈为空，不能执行此操作\n");exit(0);}e=*(S.top-1);return e;}int Push(SqStack &S,int e){if(StackLength(S)>=S.stacksize){S.base=(int*)realloc(S.base,(STACKSIZE+STACKINCREMENT)*sizeof(int));if(!S.base){printf("\n再分配存储失败\n");return 0;}S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return 1;}int Pop(SqStack &S){int e;if(StackEmpty(S)){printf("当前栈为空，不能执行此操作\n");exit(0);}e=*--S.top;return e;}void main(){int i=0,e;int *p;SqStack S;S=Initstack();printf("\n 1.元素进栈\n 2.元素出栈\n 3.取栈顶元素\n 4.求栈的长度\n 5.判栈空\n 6.退出\n");for(;i!=6;){printf("\n请选择你要进行的操作：");scanf("%d",&i);switch(i){case 1:printf("\n请输入进栈元素：");scanf("%d",&e);Push(S,e);p=S.base;printf("\n当前栈中元素：");if(StackEmpty(S))printf("当前栈为空\n");while(p!=S.top){printf("%d ",*p);p++;}break;case 2:printf("\n%d已出栈\n",Pop(S));printf("\n当前栈中元素：");if(StackEmpty(S))printf("当前栈为空\n");p=S.base;while(p!=S.top){printf("%d ",*p);p++;}break;case 3:printf("\n栈顶元素为：%d\n",GetTop(S));break;case 4:printf("\n栈的长度为：%d\n",StackLength(S));break;case 5:if(StackEmpty(S))printf("\n当前栈为空\n");else printf("\n当前栈不空\n");break;default:printf("\n退出程序\n");}}}3.顺序队列的基本操作（顺序队的初始化、进队、出对以及取对头）#include <stdio.h>#include <malloc.h>#define MAXNUM 100#define Elemtype int#define TRUE 1#define FALSE 0typedef struct{ Elemtype queue[MAXNUM];int front;int rear;}sqqueue;/*队列初始化*/int initQueue(sqqueue *q){ if(!q) return FALSE;q->front=-1;q->rear=-1;return TRUE;}/*入队*/int append(sqqueue *q, Elemtype x){ if(q->rear>=MAXNUM-1) return FALSE;q->rear++;q->queue[q->rear]=x;return TRUE;/*出队*/Elemtype Delete(sqqueue *q){ Elemtype x;if (q->front==q->rear) return 0;x=q->queue[++q->front];return x;}/*判断队列是否为空*/int Empty(sqqueue *q){ if (q->front==q->rear) return TRUE;return FALSE;}/*取队头元素*/int gethead(sqqueue *q){ if (q->front==q->rear) return 0;return(q->queue[q->front+1]);}/*遍历队列*/void display(sqqueue *q){ int s;s=q->front;if (q->front==q->rear)printf("队列空!\n");else{printf("\n顺序队列依次为：");while(s<q->rear){s=s+1;printf("%d<-", q->queue[s]);}printf("\n");printf("顺序队列的队尾元素所在位置:rear=%d\n",q->rear);printf("顺序队列的队头元素所在位置:front=%d\n",q->front);}}/*建立顺序队列*/void Setsqqueue(sqqueue *q){ int n,i,m;printf("\n请输入将要入顺序队列的长度:");scanf("%d",&n);printf("\n请依次输入入顺序队列的元素值:\n");for (i=0;i<n;i++){ scanf("%d",&m);append(q,m);}main(){ sqqueue *head;int x,y,z,select;head=(sqqueue*)malloc(sizeof(sqqueue));do{printf("\n第一次使用请初始化！\n");printf("\n请选择操作(1--7):\n");printf("===================================\n");printf("1 初始化\n");printf("2 建立顺序队列\n");printf("3 入队\n");printf("4 出队\n");printf("5 判断队列是否为空\n");printf("6 取队头元素\n");printf("7 遍历队列\n");printf("===================================\n");scanf("%d",&select);switch(select){case 1:{ initQueue(head);printf("已经初始化顺序队列！\n");break;}case 2:{ Setsqqueue(head);printf("\n已经建立队列！\n");display(head);break;}case 3:{ printf("请输入队的值:\n ");scanf("%d",&x);append(head,x);display(head);break;}case 4:{ z=Delete(head);printf("\n队头元素%d已经出队！\n",z);display(head);break;}case 5:{ if(Empty(head))printf("队列空\n");elseprintf("队列非空\n");break;}case 6:{ y=gethead(head);printf("队头元素为:%d\n",y);break;}case 7:{ display(head);break;}}}while(select<=7);}4.链队列的基本操作（链队列的初始化、进队、出对操作）#include<stdio.h>#include<stdlib.h>#define ElemType inttypedef struct Qnode{ ElemType data;struct Qnode *next;}Qnodetype;typedef struct{ Qnodetype *front;Qnodetype *rear;}Lqueue;/*初始化并建立链队列*/void creat(Lqueue *q){ Qnodetype *h;int i,n,x;printf("输入将建立链队列元素的个数：n= ");scanf("%d",&n);h=(Qnodetype*)malloc(sizeof(Qnodetype));h->next=NULL;q->front=h;q->rear=h;for(i=1;i<=n;i++){ printf("链队列第%d个元素的值为：",i);scanf("%d",&x);Lappend(q,x);}}/*入链队列*/void Lappend(Lqueue *q,int x){ Qnodetype *s;s=(Qnodetype*)malloc(sizeof(Qnodetype));s->data=x;s->next=NULL;q->rear->next=s;q->rear=s;}/*出链队列*/ElemType Ldelete(Lqueue *q){ Qnodetype *p;ElemType x;if(q->front==q->rear){ printf("队列为空!\n");x=0;}else{ p=q->front->next;q->front->next=p->next;if(p->next==NULL)q->rear=q->front;x=p->data;free(p);}return(x);}/*遍历链队列*/void display(Lqueue *q){ Qnodetype *p;p=q->front->next; /*指向第一个数据元素节点*/printf("\n链队列元素依次为：");while(p!=NULL){ printf("%d-->",p->data);p=p->next;}printf("\n\n遍历链队列结束！\n");}main(){ Lqueue *p;int x,cord;printf("\n*****第一次操作请选择初始化并建立链队列！*****\n ");do{ printf("\n 链队列的基本操作\n ");printf("=========================================\n");printf(" 主菜单\n");printf("=========================================\n");printf(" 1 初始化并建立链队列\n");printf(" 2 入链队列\n");printf(" 3 出链队列\n");printf(" 4 遍历链队列\n");printf(" 5 结束程序运行\n");printf("==========================================\n");scanf("%d",&cord);switch(cord){ case 1:{ p=(Lqueue *)malloc(sizeof(Lqueue));creat(p);display(p);}break;case 2:{ printf("请输入队列元素的值：x=");scanf("%d",&x);Lappend(p,x);display(p);}break;case 3:{ printf("出链队列元素：x=%d\n",Ldelete(p));display(p);}break;case 4:{display(p);}break;case 5:{exit (0);}}}while (cord<=5);}5.循环队列的基本操作：#include<stdio.h>#include<iostream.h>#include<malloc.h>#define maxsize 100struct Queue{int *base;int front;int rear;};void initQueue(Queue &Q){Q.base=(int *)malloc(maxsize*sizeof(int));Q.front=Q.rear=0;}int QueueLen(Queue Q){return(Q.rear-Q.front+maxsize)%maxsize;}void EnQueue(Queue &Q,int e){if((Q.rear+1)%maxsize==Q.front)cout<<"队列已满，无法插入!"<<endl;else{Q.base[Q.rear]=e; Q.rear=(Q.rear+1)%maxsize;}}int DeQueue(Queue &Q,int &e){if(Q.rear==Q.front) cout<<"队列已空，无法删除!"<<endl;else{e=Q.base[Q.front]; Q.front=(Q.front+1)%maxsize;cout<<"被删除的元素是:"<<'\t'<<e<<endl;return e;}}void main(){Queue Q;initQueue(Q);loop:cout<<'\t'<<"请选择你要进行的操作:"<<endl;cout<<'\t'<<"1.插入元素"<<endl<<'\t'<<"2.删除元素"<<endl<<'\t'<<"3.求队列长度"<<endl<<'\t'<<"4.结束"<<endl;int i; cin>>i;switch(i){case(1):{int e;cout<<"请输入要插入的元素:"<<'\t';cin>>e;EnQueue(Q,e);goto loop;}case(2):{int e;DeQueue(Q,e);goto loop;}case(3):{int l;l=QueueLen(Q);cout<<"队列的长度为:"<<'\t'<<l<<endl;goto loop;}case(4):break;default:cout<<"输入错误，请重新输入!"<<endl;goto loop;}}6.两个栈实现队列的功能#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<iostream.h>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef char SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;//队列由两个栈S1,S2构成typedef struct{SqStack S1;SqStack S2;}Queue;void InitStack(SqStack *S){S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S->base) exit(0);S->top=S->base; S->stacksize=STACK_INIT_SIZE;}void push(SqStack *S,SElemType e){if(S->top-S->base==S->stacksize){S->base=(SElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S->base) exit(0);S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*(S->top)++=e;}void pop(SqStack *S,SElemType *e){if(S->top==S->base) exit(0);S->top--; *e=*(S->top);}//队列的相关操作void InitQueue(Queue *Q){InitStack(&(Q->S1));InitStack(&(Q->S2));}void EnQueue(Queue *Q,SElemType e){push(&(Q->S1),e);}void DeQueue(Queue *Q,SElemType *e){if((Q->S2).top==(Q->S2).base){while((Q->S1).top!=(Q->S1).base){pop(&(Q->S1),e);push(&(Q->S2),*e);} pop(&(Q->S2),e);}else pop(&(Q->S2),e);}int QueueEmpty(Queue Q){if(Q.S1.base==Q.S1.top&&Q.S2.base==Q.S2.top) return 0;else return 1;}void main(){SElemType e; Queue Q; int i;InitQueue(&Q);for(i=0;i<10;i++) EnQueue(&Q,'a'+i);while(QueueEmpty(Q)!=0){DeQueue(&Q,&e); cout<<e;}cout<<endl;}7．用双端队列模拟栈#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define null 0typedef struct QNode{int data;struct QNode *next;struct QNode *prior;}QNode;typedef struct{QNode *front1,*front2;QNode *rear1,*rear2;}LinkDeque;LinkDeque InitQueue(){LinkDeque Q;Q.front1=Q.rear1=(QNode *)malloc(sizeof(QNode));if(!Q.front1){printf("\n存储分配失败\n");exit(0);}Q.front2=Q.rear2=(QNode *)malloc(sizeof(QNode));if(!Q.front2){printf("\n存储分配失败\n");exit(0);}Q.front1->next=Q.front2;Q.front2->next=Q.front1;return Q;}int EnDeque(LinkDeque &Q,int e){QNode *p;p=(QNode *)malloc(sizeof(QNode));if(!p){printf("\n存储分配失败\n");exit(0);}p->data=e;p->next=Q.front2;p->prior=Q.rear1;Q.rear1->next=p;Q.rear1=p;Q.rear2=Q.front1->next;return 1;}int DeDeque(LinkDeque &Q){int e;QNode *p;if(Q.front1==Q.rear1){printf("栈为空，不能执行删除操作\n");return 0;}p=Q.rear1;e=p->data;p->prior->next=p->next;p->next->prior=p->prior;Q.rear1=p->prior;if(Q.front1==Q.front2){Q.rear1=Q.front1;Q.rear2=Q.front2;}free(p);return e;}int DequeLength(LinkDeque Q){int len=0;QNode *p;p=Q.front1->next;while(p!=Q.front2){len++;p=p->next;}return len;}int Gethead(LinkDeque Q){QNode *p;if(Q.front1!=Q.rear1){p=Q.rear1;return p->data;}}void main(){int i=0,e;LinkDeque Q;QNode *p;Q=InitQueue();printf("\n 1.元素进栈\n 2.元素出栈\n 3.求栈的长度\n 4.取栈顶元素\n 5.退出\n");for(;i!=5;){printf("\n请选择你要进行的操作：");scanf("%d",&i);switch(i){case 1:printf("\n请输入进栈元素：");scanf("%d",&e);EnDeque(Q,e);if(Q.front1!=Q.rear1){printf("\n当前栈元素:");p=Q.front1->next;while(p!=Q.front2){printf("%d ",p->data);p=p->next;}}else printf("当前栈为空\n");break;case 2:if(Q.front1!=Q.rear1)printf("\n已删除%d\n",DeDeque(Q));else printf("栈为空，不能此删除操作\n");if(Q.front1!=Q.rear1){printf("\n当前栈元素:");p=Q.front1->next;while(p!=Q.front2){printf("%d ",p->data);p=p->next;}}else printf("当前栈为空\n");break;case 3:printf("\n栈的长度：%d",DequeLength(Q));break;case 4:if(Q.front1!=Q.rear1)printf("\n栈顶元素:%d\n",Gethead(Q));else printf("栈为空，不能此删除操作\n");break;default:printf("\n结束程序\n");}}}8.约瑟夫队列:#include<stdio.h>#include<malloc.h>#include<iostream.h>#define len sizeof(struct QNode)struct QNode{int data;QNode *next;};void main(){int m,n,k,i,e,num=1;cout<<"请输入总人数:"<<endl; cin>>n;cout<<"请输入出局数:"<<endl; cin>>m;cout<<"请输入开始报数人的编号:"<<endl; cin>>k;QNode *Q,*p,*r,*t;Q=(QNode *)malloc(len);Q->next=Q;Q->data=1;p=Q;for(i=2;i<=n;i++){p->next=(QNode *)malloc(len);p=p->next;p->data=i;}p->next=Q;r=Q;t=r;for(i=1;i<=k-1;i++){t=r;r=r->next;}cout<<"出队顺序为:"<<endl;do{for(i=1;i<=m-1;i++){t=r;r=r->next;}e=r->data;t->next=r->next;r=t->next;cout<<e<<" ";num++;}while(num<=n);cout<<endl;}【小结讨论】1. 一个程序中如果要用到两个栈时，可通过两个栈共享一维数组来实现，即双向栈共享邻接空间。

数据结构实验三栈和队列的应用

允许进行插入与删除操作的这一端称为栈顶，而另一端称为栈底，不含元素的空表称为空栈，插入与删除分别称进栈与出栈。

由于插入与删除只能在同一端进行，所以较先进入栈的元素，在进行出栈操作时，要比较后才能出栈。

特别是，最先进栈者，最后才能出栈，而最晚进栈者，必最先出栈。

因此，栈也称作后进先出（Last In First Out）的线性表，简称LIFO表。

栈示意图见图3-12. 栈的抽象数据类型定义：ADT Stack{数据对象：D={ | ∈ElemSet,i=1,2,...,n, n>=0}数据关系：R1={< , >| , ∈D,i=2,...,n}基本操作：InitStack(&S) 构造一个空栈SStackEmpty(S) 判断栈S是否为空StackLength(S) 返回栈S的元素个数,即栈的长度GetTop(S,&e) 取栈S的栈顶元素Push(&S,e) 将元素e入栈Pop(&S,&e) 删除S的栈顶元素并用e返回其值（即出栈）}ADT Stack3. 栈的表示：栈有两种存储表示方法：顺序存储结构和链式存储结构。

数据结构栈和队列实验报告

数据结构栈和队列实验报告数据结构栈和队列实验报告引言：数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便于程序的运行和管理。

栈和队列是数据结构中最基本的两种形式之一，它们在实际应用中有着广泛的应用。

本实验旨在通过实际操作和观察，深入理解栈和队列的特性和应用。

一、实验目的：1. 了解栈和队列的基本概念和特性；2. 掌握栈和队列的基本操作；3. 理解栈和队列在实际应用中的作用。

二、实验过程：本次实验我们使用Python语言来实现栈和队列的操作。

首先，我们定义了栈和队列的类，并编写了相应的操作方法。

1. 栈的实现：栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的弹簧簿记本。

我们首先定义了一个栈类，其中包括了栈的初始化、入栈、出栈、获取栈顶元素等方法。

通过这些方法，我们可以对栈进行各种操作。

2. 队列的实现：队列是一种先进先出（FIFO）的数据结构，类似于我们日常生活中的排队。

我们同样定义了一个队列类，其中包括了队列的初始化、入队、出队、获取队首元素等方法。

通过这些方法，我们可以对队列进行各种操作。

三、实验结果：我们通过实验，成功实现了栈和队列的基本操作。

在测试过程中，我们发现栈和队列在实际应用中有着广泛的用途。

1. 栈的应用：栈在计算机系统中有着重要的作用，例如在函数调用中，每次函数调用时都会将返回地址和局部变量等信息存储在栈中，以便于函数执行完毕后能够正确返回。

此外，栈还可以用于表达式求值、括号匹配等场景。

2. 队列的应用：队列在操作系统中常用于进程调度，通过维护一个就绪队列，操作系统可以按照一定的策略选择下一个要执行的进程。

此外，队列还可以用于消息传递、缓冲区管理等场景。

四、实验总结：通过本次实验，我们深入了解了栈和队列的特性和应用。

栈和队列作为数据结构中最基本的两种形式，它们在计算机科学中有着广泛的应用。

在实际编程中，我们可以根据具体的需求选择合适的数据结构，以提高程序的效率和可读性。