数据结构_实验三_栈和队列及其应用
栈和队列常见数据结构的应用与实现
栈和队列常见数据结构的应用与实现栈和队列是常见的数据结构，它们在计算机科学中有着广泛的应用与实现。
本文将介绍栈和队列的基本概念、使用场景以及具体实现方式。
一、栈的概念和应用栈是一种先进后出（Last-In-First-Out, LIFO）的数据结构，类似于我们生活中的“堆叠”。
在栈中，元素的插入和删除操作都在同一端进行，这一端被称为栈顶。
栈的应用非常广泛，其中一个典型的应用是函数的调用与返回。
在函数调用时，局部变量和参数等数据被依次压入栈中，而函数返回时则会依次从栈中弹出这些数据。
这一过程使得函数间的数据传递和操作非常方便。
另外，栈还常用于表达式求值、括号匹配、浏览器的前进后退功能等场景。
二、栈的实现栈的实现有多种方式，其中一种比较常见的是使用数组实现栈。
下面是一个简单的示例代码：```pythonclass Stack:def __init__(self):self.items = []def is_empty(self):return len(self.items) == 0def push(self, item):self.items.append(item)def pop(self):if not self.is_empty():return self.items.pop()else:raise Exception("Stack is empty") def peek(self):if not self.is_empty():return self.items[-1]else:raise Exception("Stack is empty") def size(self):return len(self.items)```上述代码中，我们使用Python中的列表来存储栈的元素，其中is_empty、push、pop、peek和size等方法分别实现了判断栈是否为空、入栈、出栈、查看栈顶元素和获取栈的大小等功能。
数据结构实验三栈和队列的应用
第三章栈和队列的应用【实验目的】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. 与栈相对应，队列是一种先进先出的线性表。
数据结构实验三栈和队列的应用
数据结构实验三栈和队列的应用数据结构实验三：栈和队列的应用在计算机科学领域中，数据结构是组织和存储数据的重要方式，而栈和队列作为两种常见的数据结构，具有广泛的应用场景。
本次实验旨在深入探讨栈和队列在实际问题中的应用，加深对它们特性和操作的理解。
一、栈的应用栈是一种“后进先出”（Last In First Out，LIFO）的数据结构。
这意味着最后进入栈的元素将首先被取出。
1、表达式求值在算术表达式的求值过程中，栈发挥着重要作用。
例如，对于表达式“2 ＋ 3 4”，我们可以通过将操作数压入栈，操作符按照优先级进行处理，实现表达式的正确求值。
当遇到数字时，将其压入操作数栈；遇到操作符时，从操作数栈中弹出相应数量的操作数进行计算，将结果压回操作数栈。
最终，操作数栈中的唯一值就是表达式的结果。
2、括号匹配在程序代码中，检查括号是否匹配是常见的任务。
可以使用栈来实现。
遍历输入的字符串，当遇到左括号时，将其压入栈；当遇到右括号时，弹出栈顶元素，如果弹出的左括号与当前右括号类型匹配，则继续，否则表示括号不匹配。
3、函数调用和递归在程序执行过程中，函数的调用和递归都依赖于栈。
当调用一个函数时，当前的执行环境（包括局部变量、返回地址等）被压入栈中。
当函数返回时，从栈中弹出之前保存的环境，继续之前的执行。
递归函数的执行也是通过栈来实现的，每次递归调用都会在栈中保存当前的状态，直到递归结束，依次从栈中恢复状态。
二、队列的应用队列是一种“先进先出”（First In First Out，FIFO）的数据结构。
1、排队系统在现实生活中的各种排队场景，如银行排队、餐厅叫号等，可以用队列来模拟。
新到达的顾客加入队列尾部，服务完成的顾客从队列头部离开。
通过这种方式，保证了先来的顾客先得到服务，体现了公平性。
2、广度优先搜索在图的遍历算法中，广度优先搜索（BreadthFirst Search，BFS）常使用队列。
从起始节点开始，将其放入队列。
实验三栈和队列的应用
实验三栈和队列的应用第一篇：实验三栈和队列的应用一、实验目的掌握栈的数据类型描述及栈的特点；掌握栈的顺序存储结构的特点及算法描述；掌握队列的数据类型描述及链式存储结构的特点和算法描述。
二、实验内容停车场管理。
设有一个可以停放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）掌握栈的基本操作的实现方法。
数据结构实验报告 栈和队列
数据结构实验报告栈和队列
栈（Stack）和队列（Queue）都是常用的数据结构。
它们都是有限的数据存储结构，主要用于记录数据的存储和检索。
它们具有许多相同的特征，可以根据每一个实例的需要而定制遍历，并可以使用相同的存储方法。
但是，从数据操作和操作数据的角度来看，它们仍有差异。
首先，栈和队列的数据操作模式不同。
栈是遵循“先进后出”（LIFO）的原则，只有最后一个元素可以被弹出或者取出；而队列则是遵循“先进先出”（FIFO）的原则，第一个元素是最先被取出或弹出的。
此外，栈不允许插入新元素，而队列允许任何位置插入和删除元素。
此外，栈只能被依次访问，而队列允许改变已有元素的位置。
此外，栈和队列可以用相似的实现方式来构建。
一般来说，它们都使用 .链表，数组或者树来存储数据，并使用相同的Pointers来指向数据结构中的元素。
栈和队列也可以使用交换的方式来改变其存储方式，从而提高其效率。
对于实际应用来说，栈和队列都有自己的优势，具体取决于应用中的需求。
比如，栈通常被用于数据的深度优先遍历，而队列则可以用于数据的广度优先遍历。
此外，栈也可以用于处理函数调用，而队列可以用于处理操作系统任务或者打印池中的任务等。
数据结构实验-线性表及其实现栈和队列及其应用
数据结构实验报告一实验名称:线性表及其实现栈和队列及其应用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");}使用以上操作，即可完成题目要求。
实验报告(3)
数据结构上机实验报告实验三栈和队列班级：13级计本二班姓名：杨宴强学号：201392130129实验三栈和队列一、实验目的：⒈学习顺序栈的基本操作2.学习链栈的基本操作3.学习循环队列基本操作4.学习链队列基本操作二、实验内容：⒈顺序栈的基本运算2.链栈的基本操作3.循环队列的基本运算4.链队列的基本运算三、实验步骤及结果：1：顺序栈#include"stdio.h"#include"stdlib.h"#define MAXSIZE 20typedef struct{char data[MAXSIZE];//栈中元素存储空间int top;//栈顶指针}SeqStack;//顺序栈类型void Init_SeqStack(SeqStack **s)//顺序栈初始化{*s=(SeqStack*)malloc(sizeof(SeqStack));//在主函数中申请栈空间(*s)->top=-1;//置栈空标志}int Empty_SeqStack(SeqStack*s)//判断栈是否为空{if(s->top==-1)//栈为空时return 1;//返回1elsereturn 0;//返回0}void Push_SeqStack(SeqStack *s,char x)//顺序栈入栈{if(s->top==MAXSIZE-1)//判断是否栈满printf("Stack is full!\n");//栈已满else{s->top++;//s指向下个节点s->data[s->top]=x;//元素x压入栈*s中}}void Pop_SeqStack(SeqStack *s,char *x)//将栈*s中的栈顶元素出栈并通过参数x返回给主调函数{if(s->top==-1)//栈空返回1printf("Stack is empty!\n");//栈为空else{*x=s->data[s->top];//栈顶元素出栈s->top--;//栈顶指针top-1}}void Top_SeqStack(SeqStack *s,char *x)//取顺序栈栈顶元素{if(s->top==-1)//栈空返回1printf("Stack is empty!\n");//栈为空else{*x=s->data[s->top];//取栈顶元素值}}void print(SeqStack *s)//顺序栈输出{int i;//定义变量ifor(i=0;i<=s->top;i++)//判断printf("%4d",s->data[i]);//读入数据printf("\n");//输出栈}void main(){SeqStack *s;//定义指针schar x,*y=&x;//y是指向x的指针，出栈元素经过y传给变量xInit_SeqStack(&s);//顺序栈初始化if(Empty_SeqStack(s))//判断栈是否为空printf("Stack is empty!\n");printf("Input data of stack:\n");//顺序栈元素入栈scanf("%c",&x);//读入数据while(x!='\n')//对x的计数直到\n结束{Push_SeqStack(s,x);//x入栈scanf("%c",&x);}printf("Output all data of stack:\n");//提示print(s);//输出顺序栈中的元素Pop_SeqStack(s,y);//顺序栈元素出栈printf("Output data of Pop stack:%c\n",*y);//输出出栈元素printf("Output all data of stack:\n");print(s);//输出出栈后顺序栈中的元素Top_SeqStack(s,y);//读取顺序栈栈顶元素printf("Output data of top stack:%c\n",*y);//输出读出的栈顶元素printf("Output all data of stack:\n");print(s);//输出当前的顺序栈中的元素}2链栈#include<stdio.h>#include<stdlib.h>typedef struct node{char data;struct node*next;}StackNode;//链栈元素类型void Init_LinkStack(StackNode**s)//链栈初始化{*s=NULL;}int Empty_LinkStack(StackNode*s)//判断链栈是否为空{if(s==NULL)return 1;elsereturn 0;}void Push_LinkStack(StackNode**top,char x)//链栈元素入栈{StackNode*p;p=(StackNode*)malloc(sizeof(StackNode));//生成存储空间p->data=x;p->next=*top;//新生成的栈顶元素*p其后继为原栈顶元素**top *top=p;//栈顶指针*top指向新的栈顶元素*p}void Pop_LinkStack(StackNode**top,char*x)//链栈元素出栈{StackNode*p;if(*top==NULL)printf("Stack is empty!\n");//栈空else{*x=(*top)->data;//栈顶元素经指针x传给对应的变量p=*top;*top=(*top)->next;free(p);}}void print(StackNode*p)//链栈输出{while(p!=NULL){printf("%c,",p->data);p=p->next;}printf("\n");}void main(){StackNode*s;char x,*y=&x;//出栈元素经指针y传给xInit_LinkStack(&s);//链栈初始化if(Empty_LinkStack(s))//判断链栈是否为空printf("Stack is empty!\n");printf("Input any string:\n");//链栈元素入栈scanf("%c",&x);while(x!='\n'){Push_LinkStack(&s,x);scanf("%c",&x);}printf("Output string:\n");//链栈输出print(s);printf("Output stack:\n");Pop_LinkStack(&s,y); //链栈元素出栈printf("Element of Output stack is %c\n",*y);//输出出栈元素printf("Output string:\n");print(s);//链栈输出}3循环队列#include"stdio.h"#include"stdlib.h"#define MAXSIZE 20typedef struct{char data[MAXSIZE];//队头元素存储空间int rear,front;//队尾和队头指针}SeQueue;//顺序队列类型void Int_SeQueue(SeQueue**q)//置空队{*q=(SeQueue*)malloc(sizeof(SeQueue));//生成循环队列的存储空间(*q)->front=0;//队尾与队头指针相等则为队空(*q)->rear=0;}int Empty_SeQueue(SeQueue*q)//判队空{if(q->front==q->rear)//判断是否队空return 1;//队空elsereturn 0;//队不空}void In_SeQueue(SeQueue*q,char x)//元素入队{if((q->rear+1)%MAXSIZE==q->front)//判断是否队满printf("Queue is full!\n");//队满，入队失败else{q->rear=(q->rear+1)%MAXSIZE;//队尾指针加1q->data[q->rear]=x;//将元素X入队}}void Out_SeQueue(SeQueue*q,char*x)//元素出队{if(q->front==q->rear)//判断是否队空printf("Queue is empty");//队空，出队失败else{q->front=(q->front+1)%MAXSIZE;//队头指针加1*x=q->data[q->front];//队头元素出对并由x返回队头元素值}}void print(SeQueue*q)//循环队列输出{int i;//定义变量ii=(q->front+1)%MAXSIZE;//i入队while(i!=q->rear)//判断队空{printf("%4c\n",q->data[i]);//读入数据信息i=(i+1)%MAXSIZE;//逐步累加}printf("%4c\n",q->data[i]);//输出}void main(){SeQueue*q;//定义指针qchar x,*y=&x;//出对元素经指针y传给xInt_SeQueue(&q);//循环队列初始化if(Empty_SeQueue(q))//判队空printf("Queue is empty!\n");//提示printf("Input any string:\n");//给循环队列输入元素scanf("%c",&x);while(x!='\n'){In_SeQueue(q,x);//元素入队scanf("%c",&x);}printf("Output elements of Queue:\n");print(q);//循环队列输出printf("Output Queue:\n");Out_SeQueue(q,y);//循环队列元素出队printf("Element of Output Queue is %c\n",*y);//输出出队元素printf("Output elements of Queue:\n");print(q);//输出出队后的循环队列元素}4.链队列#include"stdio.h"#include"stdlib.h"#define MAXSIZE 30typedef struct node{char data;struct node *next;}QNode;//链队列结点类型typedef struct{QNode *front,*rear;//将头、尾指针纳入到一个结构体的链队列}LQueue;//链队列类型void Init_LQueue(LQueue **q)//创建一个带头结点的空队列{QNode *p;*q=(LQueue*)malloc(sizeof(LQueue));//申请带头、尾指针的结点p=(QNode*)malloc(sizeof(QNode));//申请链队列的头结点p->next=NULL;//头结点的next指针置为空(*q)->front=p;//队头指针指向头结点(*q)->rear=p;//队尾指针指向头结点}int Empty_LQueue(LQueue *q)//判队空{if(q->front==q->rear)return 1;//队为空elsereturn 0;}void In_LQueue(LQueue *q,char x)//入队{QNode *p;p=(QNode*)malloc(sizeof(QNode));//申请新链队列结点p->data=x;p->next=NULL;//新结点作为队尾结点时其next域为空q->rear->next=p;//将新结点*p链到原队尾结点之后q->rear=p;//是队尾指针指向新的队尾结点*p}void Out_LQueue(LQueue *q,char *x)//出队{QNode *p;if(Empty_LQueue(q))printf("Queue is empty!\n");//队空，出队失败else{p=q->front->next;//指针p指向队头结点q->front->next=p->next;//头结点的next指针指向链队列的第二个数据结点*x=p->data;//将删除的队头结点数据经由指针x返回free(p);if(q->front->next==NULL)//出队后队为空，则置为空队列q->rear=q->front;}}void print(LQueue *q)//链队列输出{QNode *p;p=q->front->next;while(p!=NULL){printf("%4c",p->data);p=p->next;}printf("\n");}void main(){LQueue *q;char x,*y=&x;//出队元素经指针y传给xInit_LQueue(&q);//链队列初始化if(Empty_LQueue(q))//判队空printf("Queue is empty!\n");printf("Input any string:\n");//给链队列输入元素scanf("%c",&x);while(x!='\n'){In_LQueue(q,x);scanf("%c",&x);//元素入队}printf("Output elements of Queue:\n");print(q);//链队列输出printf("Output Queue:\n");Out_LQueue(q,y);//元素出队printf("Element of Output Queue is %c\n",*y);//输出出队的元素值printf("Output elements of Queue:\n");print(q);//输出出队后链队列的元素}四、实验总结：通过本次试验，了解了栈和队列的基本操作。
数据结构_实验三_栈和队列及其应用
数据结构_实验三_栈和队列及其应用实验编号: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) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列)。
数据结构栈和队列的应用场景
数据结构栈和队列的应用场景数据结构是计算机领域中的核心概念之一，它是用来组织和存储数据的一种方式。
在数据结构中，栈（Stack）和队列（Queue）是两个常用的数据结构，它们都有各自的特点和适用的应用场景。
本文将介绍栈和队列的基本概念，并探讨它们在不同领域中的广泛应用。
一、栈的应用场景栈是一种后进先出（LIFO）的数据结构，即最后插入的数据最先被取出。
栈的应用场景较为广泛，以下是几个常见的应用场景。
1. 编辑器的撤销操作在图像编辑器、文本编辑器等应用中，撤销操作是一个常用的功能。
撤销操作需要将用户的每一步操作保存在一个栈中，当用户点击撤销按钮时，系统会从栈顶取出最后的操作进行恢复，实现了用户对编辑操作的撤销与恢复。
2. 网页浏览器中的后退功能在网页浏览器中，通过使用栈结构来实现后退功能。
每当用户访问一个新的网页时，系统会将该网页的 URL 入栈；当用户点击后退按钮时，系统会从栈顶取出上一次访问的网页 URL，然后加载该网页。
3. 函数调用的堆栈在计算机编程中，函数调用是一个常见的操作。
当一个函数被调用时，程序会将函数的返回地址和参数等信息存储在一个栈帧中，并将栈帧入栈。
当函数执行完成后，程序会从栈顶取出栈帧，返回到函数调用的上一级。
二、队列的应用场景队列是一种先进先出（FIFO）的数据结构，即最先插入的数据最先被取出。
队列的应用场景也非常广泛，以下是几个常见的应用场景。
1. 任务调度在操作系统中，任务调度是一个重要的功能。
操作系统通常使用队列来管理待执行的任务，每当一个任务完成时，系统会从队列中取出下一个任务进行执行。
这样可以保证任务按照顺序逐个执行，确保系统的稳定性和效率。
2. 消息队列在分布式系统和消息中间件中，消息队列被广泛应用。
消息队列可以实现不同系统之间的解耦和异步通信，发送方将消息放入队列，接收方从队列中取出消息进行处理，有效地解决了系统之间的通信和数据传输问题。
3. 广度优先搜索（BFS）在图论算法中，广度优先搜索是一种常用的算法，它需要使用队列来辅助实现。
数据结构_实验三_栈和队列及其应用
}
//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）编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);
栈与队列了解栈和队列的特性及应用场景
栈与队列了解栈和队列的特性及应用场景栈与队列: 了解栈和队列的特性及应用场景栈（Stack）和队列（Queue）是计算机科学中常用的数据结构。
它们在算法和程序设计中起着重要的作用，能够有效地处理各种问题。
本文将介绍栈和队列的特性，并探讨它们在实际应用中的场景。
一、栈的特性及应用场景栈是一种具有特殊的操作顺序的数据结构，遵循"先进后出"（Last-In-First-Out, LIFO）的原则。
栈可理解为一种线性表，只能在一端进行插入和删除操作。
1. 栈的基本操作栈主要有两个基本操作：入栈（Push）和出栈（Pop）。
入栈将元素插入栈顶，而出栈将栈顶元素删除并返回。
此外，栈还有一个重要的操作是查看栈顶元素而不进行出栈，称为读取（Peek）。
2. 应用场景栈在许多实际问题中都有广泛的应用。
以下是一些常见的例子： - 函数调用栈：在程序执行过程中，每次函数调用都会将函数的局部变量及返回地址保存在栈中，函数返回时再通过出栈操作恢复上一层函数的执行。
- 括号匹配：栈可以用来检查括号是否匹配，遇到左括号时入栈，遇到右括号时出栈并与之匹配。
如果最后栈为空，则表示所有括号都正确匹配。
- 浏览器的前进与后退：浏览器中的前进与后退功能可以使用两个栈来实现，一个栈用来保存前进的网页，另一个栈用来保存后退的网页。
二、队列的特性及应用场景队列是一种具有特殊操作顺序的数据结构，遵循"先进先出"（First-In-First-Out, FIFO）的原则。
队列可理解为一种线性表，只能在一端进行插入操作，在另一端进行删除操作。
1. 队列的基本操作队列主要有两个基本操作：入队（Enqueue）和出队（Dequeue）。
入队将元素插入队尾，而出队将队头元素删除并返回。
2. 应用场景队列在计算机科学中有广泛的应用。
以下是一些常见的例子：- 线程池任务调度：线程池中的任务通常以队列的形式存储，通过出队操作获取任务并交给空闲的线程进行处理。
实验三栈和队列及其应用(I)讲解
姓名学号void print(void);int main(void){system("title 数据结构实验实验三：栈和队列及其应用（I） "); //设置cmd窗口标题system("color F1"); //设置控制台窗口的背景色和前景色system("date /T"); //输出当前的日期print();cout << "实验内容一：采用顺序存储结构，实现栈的存储和基本操作"<< endl;SqStack S;SElemType e;InitStack_Sq(S); //构造一个空栈Sint count;cout << "请输入需入栈的元素个数：N = ";cin >> count;cout << "请输入元素：";for (int i = 0; i < count; i++){cin >> e;Push_Sq(S, e);}GetTop_Sq(S, e);cout << " 栈顶元素：" << e << endl;cout << " 出栈：";while ((Pop_Sq(S, e)))cout << e << " ";cout << endl << "栈的应用："<< endl << "1.将十进制数转换为二进制数"<< endl;DecToBin(); //将十进制数转换为二进制数cout << "2.汉罗塔问题" << endl << " 请输入圆盘个数：";int n; //圆盘个数char x = 'A', y = 'B', z = 'C';cin >> n;cout << "圆盘移动步骤：";Hanoi(n, x, y, z);DestoryStack_Sq(S); //销毁栈Scout << endl;print();cout << "实验内容二：采用顺序存储结构，实现队列的存储和基本操作" << endl;SqQueue Q;QElemType data;InitQueue_Sq(Q); //构造一个空队列Qcout << "请输入需入队列的元素个数：N = ";cin >> count;cout << "请输入元素：";for (int i = 0; i < count; i++){cin >> data;EnQueue_Sq(Q, data);}GetHead_Sq(Q, data);cout << " 队首元素：" << data << endl;cout << " 出队列：";while (DeQueue_Sq(Q, data))cout << data << " ";cout << endl;print();cout << endl;}void print(void){cout << endl <<"***********************************************************" << endl; }2.头文件”ADT.h”的部分程序如下：#ifndef ADT_H_#define ADT_H_/************************************************************* 常量和数据类型预定义************************************************************//* ------函数结果状态代码------ */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2/* ------数据类型预定义------ */typedef int Status; //函数结果状态类型typedef int_bool; //bool状态类型/************************************************************* 数据结构类型定义************************************************************//************************栈和队列*************************//* ------栈数据类型定义------ */typedef int SElemType; //顺序表中元素的数据类型/* ------栈动态存储分配初始常量预定义------ */#define STACK_INIT_SIZE 100 //栈表存储空间的初始分配量#define STACKINCREMENT 10 //栈表存储空间的分配增量/* ------顺序栈结构类型定义------ */typedef struct{SElemType * base; //栈底指针SElemType * top; //栈顶指针int stacksize; //当前以分配的存储空间}SqStack; //顺序栈结构类型/* ------队列数据类型定义------ */typedef int QElemType; //顺序表中元素的数据类型/* ------队列动态存储分配初始常量预定义------ */#define QUEUE_INIT_SIZE 100 //队列存储空间的初始分配量#define QUEUEINCREMENT 10 //队列存储空间的分配增量#define MAXQUEUESIZE 100 //循环队列最大长度/* ------队列顺序存储结构类型定义------ */typedef struct{QElemType *base; //队列初始化动态分配存储空间int front; //对头指针向量，队列不空，指向队头元素int rear; //队尾指针向量，队列不空，指向队尾下一个位置}SqQueue; //顺序队列结构类型#endif/* ADT_H_ */3.头文件"DataStructure_StackQueue.h"中部分函数定义如下：#include<stdio.h>#include<malloc.h>#include"ADT.h"/************************************************************* 功能函数声明区************************************************************//* ---------栈--------- *///栈的基本操作Status InitStack_Sq(SqStack &S); //构造一个空顺序栈SStatus GetTop_Sq(SqStack &S, SElemType &e); //返回栈顶元素eStatus StackEmpty_Sq(SqStack &S); //判断栈S是否为空Status DestoryStack_Sq(SqStack &S); //销毁顺序栈SStatus Push_Sq(SqStack &S, SElemType e); //元素e压入顺序栈Status Pop_Sq(SqStack &S, SElemType &e); //元素e出栈//栈的应用Status DecToBin(void); //十进制数转换为二进制数void Hanoi(int n, char x, char y, char z); //实现Hanoi问题，借助y塔将x塔上的n个圆盘搬移到z塔上/* ---------队列--------- *///队列的基本操作Status InitQueue_Sq(SqQueue &Q); //构造一个空的顺序队列Q Status GetHead_Sq(SqQueue &Q, QElemType &e); //返回顺序队列的队头元素e Status EnQueue_Sq(SqQueue &Q, QElemType e); //将元素e插入到队列Q中Status DeQueue_Sq(SqQueue &Q, QElemType &e); //将元素e从顺序队列中删除并返回Status InverseQueue_Sq(SqQueue &Q); //实现队列的逆置/************************************************************* 功能函数定义区************************************************************//***************栈结构函数定义****************//** 函数原型：Status InitStack_Sq(SqStack &S)* 函数功能：构造一个空栈S* 入口参数：SqStack类型的结构体变量S的引用&S* 出口参数：返回函数结果状态*/Status InitStack_Sq(SqStack &S){S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));if (!S.base)return(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;} //InitStack_Sq/** 函数原型：Status DestoryStack_Sq(SqStack &S)* 函数功能：销毁栈S* 入口参数：SqStack类型的结构体变量S的引用&S* 出口参数：返回函数结果状态*/Status DestoryStack_Sq(SqStack &S){SElemType *p;while (S.base != S.top){p = --S.top;free(p);}return OK;} //DestoryStack_Sq/** 函数原型：Status Push_Sq(SqStack &S, SElemType e)* 函数功能：将元素e入栈* 入口参数：SqStack类型的结构体变量S的引用&S,SElemType类型元素e* 出口参数：返回函数结果状态*/Status Push_Sq(SqStack &S, SElemType e){SElemType *newbase;if (S.top - S.base >= S.stacksize){newbase = (SElemType *)realloc(S.base, (STACKINCREMENT +S.stacksize)*sizeof(SElemType));if (!newbase)return OVERFLOW;S.base = newbase;S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;} //Push_Sq/** 函数原型：Status Pop_Sq(SqStack &S, SElemType &e)* 函数功能：将元素e出栈* 入口参数：SqStack类型的结构体变量S的引用&S,SElemType类型元素e的引用&e * 出口参数：返回函数结果状态*/Status Pop_Sq(SqStack &S, SElemType &e){if (S.top == S.base)return ERROR;e = * --S.top;return OK;} //Pop_Sq/** 函数原型：Status DecToBin(void)* 函数功能：将十进制数转换为二进制* 入口参数：void* 出口参数：返回函数结果状态*/Status DecToBin(void){LinkStack S;SElemType e;long data;printf(" 请输入待转换的十进制数：");scanf_s("%d", &data);InitStack_L(S);while (data){Push_L(S, data % 2);data = data / 2;}printf(" 转换后的二进制数：");while (S->next){Pop_L(S, e);printf("%d", e);}printf("\n");return OK;} //DecToBin/***************队列结构函数定义****************//** 函数原型：Status InitQueue_Sq(SqQueue &Q)* 函数功能：构造一个空队列Q* 入口参数：SqQueue类型的结构体变量Q的引用 &Q* 出口参数：返回函数结果状态*/Status InitQueue_Sq(SqQueue &Q){Q.base = (QElemType *)malloc(QUEUE_INIT_SIZE * sizeof(QElemType));if (!Q.base)return(OVERFLOW);Q.front = Q.rear = 0;return OK;} //InitQueue_Sq/** 函数原型：Status GetHead_Sq(SqQueue &Q, QElemType &e)* 函数功能：若队列不空，则返回队头元素e,并返回函数结果状态OK，否则返回ERROR * 入口参数：SqQueue类型的结构体变量Q的引用&Q,QElemType类型元素e的引用&e * 出口参数：返回函数结果状态*/Status GetHead_Sq(SqQueue &Q, QElemType &e){if (Q.front == Q.rear)return ERROR;e = Q.base[Q.rear - 1]; //队尾指针向量指向下一个元素return OK;} //GetHead_Sq/** 函数原型：Status EnQueue_Sq(SqQueue &Q, QElemType e)* 函数功能：将元素e插入到队列Q中* 入口参数：SqQueue类型的结构体变量Q的引用&Q,QElemType类型元素e* 出口参数：返回函数结果状态*/Status EnQueue_Sq(SqQueue &Q, QElemType e){QElemType *newbase;if (Q.front - Q.rear >= QUEUE_INIT_SIZE){newbase = (QElemType *)realloc(Q.base, (STACKINCREMENT + QUEUE_INIT_SIZE)*sizeof(QElemType));if (!newbase)return OVERFLOW;Q.base = newbase;}Q.base[Q.rear++] = e;return OK;} //EnQueue_Sq/** 函数原型：Status DeQueue_Sq(SqQueue &S, QElemType &e)* 函数功能：将元素e从队列中删除并返回* 入口参数：SqQueue类型的结构体变量Q的引用&Q,QElemType类型元素e的引用&e* 出口参数：返回函数结果状态*/Status DeQueue_Sq(SqQueue &Q, QElemType &e){if (Q.front == Q.rear)return ERROR;e = Q.base[Q.front++];return OK;} //DeQueue_Sq运行结果实验总结1、此次实验完成了对顺序存储结构的栈和队列的基本操作及简单应用，加深了对课本知识的理解和掌握。
数据结构实验指导书 栈和队列的应用
一、实验名称：栈和队列的应用
二、实验目的和要求：
1．掌握栈和队列的概念和特点
2．掌握栈和队列在顺序和链式存储结构下的插入、删除算法
3．认真分析项目实例中的内容，将相关程序在计算机上运行实现
三、上机实验内容一：表达式求值问题
1．求一个数学表达式的值：用户输入一个包含正整数、括号和四则运算符（“+”、“—”、“*”、“/”）的算术表达式，计算其结果。
2．设计分析
首先置操作数栈为空栈，表达式起始符“#”为运算符栈底元素；依次读入表达式中每个字符，若是操数则进操作数栈，若是操作符则和操作符栈顶的运算符进行比较优先权后作相应的操作，直到整个表达式求值完毕（即操作符栈顶元素和当前读入的字符均为“#”）
3．结点结构类型描述如下
typedef struct
{
char *base,*top;
int stacksize;
}sqstack;
四、上机实验内容二：迷宫求解问题
1.迷宫是一个m行n列的矩阵，其中0表示无障碍，1表示有障碍。
设入口为（1，1），出口为（m,n），即从入口出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路退回，换一个方向再继续探索，直到出口为止。
2.迷宫的功能
要求随机生成一个m行n列的矩阵，为了操作方便可以在矩阵外围生成一圏障碍，设置东南西北四个方向，采用链栈进行操作。
最后迷宫如不是通路给出
“此迷宫元解”，如是通路要求输出所走过的路径。
3．结点结构类型描述如下
typedef struct node
{ int row;
int col;
struct node *next;
};。
数据结构3栈和队列
使用循环队列来实现。循环队列是将一维数组看作一个首尾相接的圆环，通过两个指针（头指针和尾 指针）来标识队列的头和尾。入队时，将元素添加到队尾；出队时，删除队头元素。
链式存储结构实现
栈的链式存储结构
使用链表来实现。链表的头结点作为栈顶， 链表的尾结点作为栈底。入栈时，在链表头 部插入元素；出栈时，删除链表头部的元素 。
输入 标题
树
树是一种分层的数据结构，由节点和边组成。树常用 于实现层次化数据结构，如文件系统、XML文档解析 等。
链表
图
哈希表是一种通过哈希函数将键映射到值的数据结构， 可以实现快速的查找、插入和删除操作。哈希表常用
于实现字典、缓存等数据结构。
哈希表
图是一种由节点和边组成的数据结构，可以表示任意 复杂的关系网络。图常用于实现网络分析、路径规划 等算法。
数据结构3栈和队列
contents
目录
• 栈与队列基本概念 • 栈操作及应用 • 队列操作及应用 • 栈和队列实现方式 • 经典问题解析与算法设计 • 总结回顾与拓展延伸
01 栈与队列基本概念
栈定义及特点
栈（Stack）是一种特殊的线性数据结 构，其操作只能在一端进行，遵循后 进先出（LIFO, Last In First Out）的 原则。
栈在函数调用中应用
函数调用栈
在程序执行过程中，每当调用一个函数时，系统会将该函数的信息（如参数、局部变量、返回地址等）压入一个 专门的栈中，称为函数调用栈。当函数执行完毕返回时，系统会从函数调用栈中弹出相应的信息，以恢复调用函 数的状态。
递归调用实现
递归函数在调用自身时，系统会将递归调用的信息压入函数调用栈中，包括递归参数、局部变量、返回地址等。 当递归到最底层时开始逐层返回，系统会从函数调用栈中弹出相应的信息进行处理，直到所有递归调用都处理完 毕为止。
数据结构------栈和队列的应用
/*实验三、四：栈和队列的应用――迷宫问题实验（实验性质：综合性实验）题目：假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为(1，1)，出口坐标为(m，n)，试找出一条从入口通往出口的最短路径。
设计算法并编程输出一条通过迷宫的最短路径或报告一个"无法通过"的信息。
要求：用栈和队列实现，不允许使用递归算法。
注：若改变迷宫形状，可能会出错，有待改进！！！*/#include"stdio.h"#include"stdlib.h"typedef struct //定义栈结构体{int *base;int *top;}sqstack;int mg[10][10];sqstack initstack(sqstack s) //初始化迷宫{s.base=(int*)malloc(sizeof(sqstack));s.top=s.base;return s;}sqstack push(sqstack s,int i,int j) //进栈{int *p=s.top;*p++=i;*p++=j;return s;}sqstack pop(sqstack s) //出栈{s.top=s.top-2;return s;}void print() //打印迷宫{int i,j;for(i=1;i<=10;i++){for(j=1;j<=10;j++){if(mg[i][j]==1) printf("入");if(mg[i][j]==2) printf("出");if(mg[i][j]==11) printf("■");if(mg[i][j]==13) printf("★");else if(mg[i][j]==0||mg[i][j]==14) printf("□");}printf("\n");}printf("\n");}void jmg() //建迷宫{int i,j;for(i=1;i<=10;i++)for(j=1;j<=10;j++)mg[i][j]=0;mg[1][1]=1; //起点mg[10][10]=2; //终点for(i=2,j=2;i<=6;i++) mg[i][j]=11; //11代表墙for(i=4,j=4;i<=8;i++) mg[i][j]=11; //11代表墙for(i=1,j=6;i<=8;i++) mg[i][j]=11; //11代表墙for(i=4,j=8;i<=10;i++) mg[i][j]=11; //11代表墙for(i=1,j=10;i<=9;i++) mg[i][j]=11; //11代表墙for(i=1,j=7;j<=9;j++) mg[i][j]=11; //11代表墙for(i=8,j=2;j<=5;j++) mg[i][j]=11; //11代表墙for(i=10,j=2;j<=8;j++) mg[i][j]=11; //11代表墙printf("\n\n迷宫：\n\n"); //打印迷宫□路通■墙11 ★路13 走过但不通print();}void road(sqstack s) //找路{int i,j,jz;jmg();i=1,j=1;while(i!=10&&j!=10){while(1){if(mg[i][j+1]==0) {jz=1;j=j+1;mg[i][j]=13;push(s,i,j);break;} //右if(mg[i+1][j]==0) {jz=2;i=i+1;mg[i][j]=13;push(s,i,j);break;} //下if(mg[i][j-1]==0) {jz=3;j=j-1;mg[i][j]=13;push(s,i,j);break;} //左if(mg[i-1][j]==0) {jz=4;i=i-1;mg[i][j]=13;push(s,i,j);break;} //上pop(s);mg[i][j]=14; //记住走过的路if(jz==1) j--;if(jz==2) i--;if(jz==3) j++;if(jz==4) i++;}}printf("\n\n迷宫通道★：\n\n"); //打印迷宫□路通■墙11 ★路13 走过但不通print();}void main(){sqstack s;s=initstack(s);road(s);}。
数据结构实验三栈和队列的应用
第三章栈和队列的应用【实验目的】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. 与栈相对应，队列是一种先进先出的线性表。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验编号：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.顺序储存：
代码部分：
栈" << endl;
cout << " 2.出栈" << endl;
cout << " 3.判栈空" << endl;
cout << " 4.返回栈顶部数据" << endl;
cout << " 5.栈长" << endl;
cout << " 0.退出系统" << endl;
cout << "你的选择是：" ;
}
链式储存：
代码部分：
栈"<<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;
}
}
}
1.
过用工程将文件分类后还是清晰简单了些.也方便修改.
注：实验成绩等级分为（90－100分）优，（80－89分）良，(70-79分)中，（60－69分）及格，（59分）不及格。