实验二栈与队列操作实验题目

合集下载

实验二栈和队列的基本操作实现及其应用

实验二栈和队列的基本操作实现及其应用一、实验目的1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。

2、会用栈和队列解决简单的实际问题。

二、实验内容（可任选或全做）题目一、试写一个算法，判断依次读入的一个以@为结束符的字符序列，是否为回文。

所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。

相关常量及结构定义：# define STACK_INIT_SIZE 100# define STACKINCREMENT 10# define OK 1# define ERROR 0typedef int SElemType;//栈类型定义typedef struct SqStack{ SElemType *base;SElemType *top;int stacksize;}SqStack;设计相关函数声明：判断函数：int IsReverse()栈：int InitStack(SqStack &S )int Push(SqStack &S, SElemType e )int Pop(SqStack &S,SElemType &e)int StackEmpty(s)题目二、编程模拟队列的管理，主要包括：出队列、入队、统计队列的长度、查找队列某个元素e、及输出队列中元素。

[实现提示]：参考教材循环队列的有关算法，其中后两个算法参考顺序表的实现。

题目三、RailsDescriptionThere is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited thattime. It was possible to establish only a surface track. Moreover, it turned out that the station could be only a dead-end one (see picture) and due to lack of available space it could have only one track.The local tradition is that every train arriving from the direction A continues in the direction B with coaches reorganized in some way. Assume that the train arriving from the direction A has N <= 1000 coaches numbered in increasing order 1, 2, ..., N. The chief for train reorganizations must know whether it is possible to marshal coaches continuing in the direction B so that their order will be a1, a2, ..., aN. Help him and write a program that decides whether it is possible to get the required order of coaches. You can assume that single coaches can be disconnected from the train before they enter the station and that they can move themselves until they are on the track in the direction B. You can also suppose that at any time there can be located as many coaches as necessary in the station. But once a coach has entered the station it cannot return to the track in the direction A and also once it has left the station in the direction B it cannot return back to the station.InputThe input consists of blocks of lines. Each block except the last describes one train and possibly more requirements for its reorganization. In the first line of the block there is the integer N described above. In each of the next lines of the block there is a permutation of 1, 2, ..., N. The last line of the block contains just 0.The last block consists of just one line containing 0.OutputThe output contains the lines corresponding to the lines with permutations in the input.A line of the output contains Yes if it is possible to marshal the coaches in the order required on the corresponding line of the input. Otherwise it contains No. In addition,there is one empty line after the lines corresponding to one block of the input. There is no line in the output corresponding to the last ``null'' block of the input. Sample Input51 2 3 4 55 4 1 2 366 5 4 3 2 1Sample OutputYesNoYes题目四、Sliding WindowDescriptionAn array of size n≤ 106 is given to you. There is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves rightwards by one position. Following is an example:The array is [1 3 -1 -3 5 3 6 7], and k is 3.Window position Minimum value Maximum value[1 3 -1] -3 5 3 6 7 -131 [3 -1 -3] 5 3 6 7 -331 3 [-1 -3 5] 3 6 7 -351 3 -1 [-3 5 3] 6 7 -351 3 -1 -3 [5 3 6] 7 361 3 -1 -3 5 [3 6 7]37Your task is to determine the maximum and minimum values in the sliding window at each position.InputThe input consists of two lines. The first line contains two integers n and k which are the lengths of the array and the sliding window. There are n integers in the second line.OutputThere are two lines in the output. The first line gives the minimum values in the window at each position, from left to right, respectively. The second line gives the maximum values.Sample Input8 31 3 -1 -3 5 3 6 7Sample Output-1 -3 -3 -3 3 33 3 5 5 6 7题目五（选作考查串知识）DNA Evolution【Description】Evolution is a seemingly random process which works in a way which resembles certain approaches we use to get approximate solutions to hard combinatorial problems. You are now to do something completely different.Given a DNA string S from the alphabet {A,C,G,T}, find the minimal number of copy operations needed to create another string T. You may reverse the strings you copy, and copy both from S and the pieces of your partial T. You may put these pieces together at any time. You may only copy contiguous parts of your partial T, and all copied strings must be used in your final T.Example: From S= “ACTG” create T= “GTACTAATAAT”1.Get GT......... by copying and reversing "TG" from S.2.Get GT AC... by copying "AC" from S.3.Get GTAC TA….. by copying "TA" from the partial T.4.Get GTACTA AT by copying and reversing "TA" from the partial T.5.Get GTACTAAT AAT by copying "AAT" from the partial T.【Input】The first line of input gives a single integer, 1 ≤k≤10, the number of test cases. Then follow, for each test case, a line with the string S , length of S is less then 19, and a line with the string T , length of T is less then 19.【Output】Output for each test case the number of copy operations needed to create T from S, or "impossible" if it cannot be done.【Sample Input】4ACGTTGCAACACGTTCGATCGAAAAAAAAAAAAAAAAAAAA【Sample output】1impossible46题目六（选作考查数组知识）Magic Squares描述Following the success of the magic cube, Mr. Rubik invented its planar version, called magic squares. This is a sheet composed of 8 equal-sized squares:1 2 3 48 7 6 5In this task we consider the version where each square has a different color. Colors are denoted by the first 8 positive integers. A sheet configuration is given by the sequence of colors obtained by reading the colors of the squares starting at the upper left corner and going in clockwise direction. For instance, the configuration of Figure 3 is given by the sequence (1,2,3,4,5,6,7,8). This configuration is the initial configuration.Three basic transformations, identified by the letters `A', `B' and `C', can be applied to a sheet:∙'A': exchange the top and bottom row,∙'B': single right circular shifting of the rectangle,∙'C': single clockwise rotation of the middle four squares.Below is a demonstration of applying the transformations to the initial squares given above:A:8 7 6 51 2 3 4B:4 1 2 35 8 7 6C:1 72 48 6 3 5All possible configurations are available using the three basic transformations.You are to write a program that computes a minimal sequence of basic transformations that transforms the initial configuration above to a specific target configuration.输入A single line with eight space-separated integers (a permutation of (1..8)) that are the target configuration.输出样例输入2 6 8 4 5 73 1样例输出7BCABCCB三、实验步骤㈠、数据结构与核心算法的设计描述㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结四、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）//int IsReverse(){ ….while( (e=getchar())!='@'){e 依次入栈、入队 //push(S,e);EnQueue(Q,e);……..}While(!StackEmpty(S)) { pop(S,a);DeQueue(Q,b);If(a!=b) return 0;}return 1;}。

栈和队列习题

栈和队列习题4．1 判断题(在你认为正确的题后的括号中打√，否则打X)。

(1)堆栈和队列都是特殊的线性表。

( )(2)堆栈和队列都将插入和删除操作限制在表的端点处进行。

( )(3)只允许在表的一端进行插入和删除操作的线性表称为堆栈。

( )(4)没有元素的堆栈称为空栈，空栈用不着栈顶指针。

( )(5)只要堆栈不空，就能任意删除堆栈的元素。

( )(6)堆栈允许删除的一端称为栈顶，而栈底元素是不能删除的。

( )(7)n个元素进栈的顺序一定与它们出栈的顺序相反。

( )(8)对采用链式存储结构的堆栈进行操作不必判断溢出。

( )(9)给出顺序堆栈的栈顶元素位置的指针是一个指针类型的变量。

( )(10)判断顺序堆栈是否为空的标志是top是否等于0(top为栈顶指针)。

( )(11)插入和删除操作比较简单是链接堆栈和链接队列的优点之一。

( )(12)n个元素进队的顺序与它们出队的顺序一定是相同的。

( )(13)没有任何元素的队列称为空队。

空队用不着队头指针与队尾指针。

( )(14)元素进出队列一定满足“先进先出”的规律。

( )(15)链接队列不存在溢出问题。

( )(16)在链接队列中删除一个元素是在链表的最前端进行的。

( )(17)采用循环链表作为存储结构的队列称为循环队列。

( )(18)堆栈和队列都可以用来解决递归问题。

( )(19)堆栈和队列都不适合采用散列存储方法。

( )(20)无论是顺序队列还是链接队列，插入、删除操作的时间复杂度都是O(1)。

( )4．2单项选择题。

(1)堆栈和队列的共同之处在于它们具有相同的——。

A．逻辑特性B．物理特性C．运算方法D．元素类型(2)堆栈和队列都是特殊的线性表，其特殊性在于_______。

A．它们具有一般线性表所没有的逻辑特性B．它们的存储结构比较特殊C．对它们的使用方法做了限制D．它们比一般线性表更简单(3)若5个元素的出栈序列为1，2，3，4，5，则进栈序列可能是——。

数据结构栈和队列习题及答案

习题三栈和队列一单项选择题1. 在作进栈运算时,应先判别栈是否(① ),在作退栈运算时应先判别栈是否(② )。

当栈中元素为n个,作进栈运算时发生上溢,则说明该栈的最大容量为(③ )。

①, ②: A. 空 B. 满 C. 上溢 D. 下溢③: A. n-1 B. n C. n+1 D. n/22．若已知一个栈的进栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，...，pn，若p1＝3，则p2为( )。

A 可能是2B 一定是2C 可能是1D 一定是13. 有六个元素6，5，4，3，2，1 的顺序进栈，问下列哪一个不是合法的出栈序列？（）A. 5 4 3 6 1 2B. 4 5 3 1 2 6C. 3 4 6 5 2 1D. 2 3 4 1 5 64.设有一顺序栈S，元素s1,s2,s3,s4,s5,s6依次进栈，如果6个元素出栈的顺序是s2,s3,s4, s6, s5,s1,则栈的容量至少应该是（）A.2B. 3C. 5D.65. 若栈采用顺序存储方式存储，现两栈共享空间V[1..m]，top[i]代表第i个栈( i =1,2)栈顶，栈1的底在v[1]，栈2的底在V[m]，则栈满的条件是（）。

A. |top[2]-top[1]|=0B. top[1]+1=top[2]C. top[1]+top[2]=mD. top[1]=top[2]6. 执行完下列语句段后，i值为：（）int f(int x){ return ((x>0) ? x* f(x-1):2);}int i ;i =f(f(1));A．2 B. 4 C. 8 D. 无限递归7. 表达式3* 2^(4+2*2-6*3)-5求值过程中当扫描到6时，对象栈和算符栈为（），其中^为乘幂。

A. 3,2,4,1,1；(*^(+*-B. 3,2,8；(*^-C. 3,2,4,2,2；(*^(-D. 3,2,8；(*^(-8. 用链接方式存储的队列，在进行删除运算时（）。

天大数据结构_实验作业二_栈(顺序栈)+队列(循环队列)

实验作业二：栈（顺序栈）和队列（循环队列）1. 将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。

当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。

两个栈均从两端向中间增长。

当向第0号栈插入一个新元素时，使top[0]增1得到新的栈顶位置，当向第1号栈插入一个新元素时，使top[1]减1得到新的栈顶位置。

当top[0]+1 == top[1]时或top[0] == top[1]-1时，栈空间满，此时不能再向任一栈加入新的元素。

试定义这种双栈(Double Stack)结构的类定义，并实现判栈空、判栈满、插入、删除算法。

2. 求fibonacci数列算法，并比较。

（递归+非递归）（非递归方法可查阅其他资料）编写实习报告要求：一、需求分析二、概要设计1.抽象数据类型2.算法三、详细设计程序代码（注释）四、调试分析调试过程中所做的工作，时间复杂度等五、测试结果输入数据和输出数据示例六、说明（如果有）编程语言：C语言或C++语言实习报告提交方式：下次上机前，将实习报告(.doc)和源程序(.cpp)压缩成一个rar 文件，文件名称为学号_班级_姓名_第几次作业。

例如：3010216155_六班_张三_第二次作业.rar。

实习报告作为本课程的平时成绩。

抄袭、雷同，双方均为0分。

第一题：一、需求分析程序要求建立一个共享栈，分配一个存储空间，两个栈分别位于两头。

并实现对两个栈的插入，删除，和判断栈满和栈空。

栈的位置不同，所以要求对不同栈的插入和删除采用不同的算法。

二、概要设计1.抽象数据类型typedef struct {int *base;int *top;int stacksize;}stack;2.算法1.建立栈。

int instack(stack &s,stack &w,int length){s.base=(int *)malloc(length*sizeof(length));w.base=s.base+length;if(!s.base||!w.base) return 0;else{s.top=s.base;w.top=w.base;s.stacksize=length;w.stacksize=length;}return 1;}2.判断栈空。

数据结构练习题栈和队列

栈和队列1 简述栈和线性表的区别。

2 简述栈和队列这两种数据结构的相同点和不同点。

3 如果进栈的元素序列为A，B，C，D，则可能得到的出栈序列有多少种？写出全部的可能序列。

4 如果进栈的元素序列为1，2，3，4，5，6，能否得到4，3，5，6，1，2和1，3，5，4，2，6的出栈序列？并说明为什么不能得到或如何得到。

5 写出下列程序段的运行结果（栈中的元素类型是char）：main( ){SEQSTACK s,*p;char x, y;p = &s;initstack(p);x = ′c′; y = ′k′;push(p,x); push(p,′a′); push(p,y);x = pop(p);push(p,′t′); push(p,x);x = pop(p);push(p,′s′);while(!empty(p)){ y = pop(p);printf(″%c″,y);}printf(″%c＼n″,x);}6 将一个非负十进制整数转换成二进制数，用非递归算法和递归算法来实现。

7 写一算法将一顺序栈中的元素依次取出，并打印元素值。

8 设单链表中存放着n个字符，试编一算法，判断该字符串是否有中心对称关系，例如xyzzyx，xyzyx都算是中心对称的字符串。

9 写出下列程序段的运行结果（队列中的元素类型是char）：main( ){SEQQUEUE a, *q;char x, y;q = &a;x=′e′; y=′c′;initqueue(q);enqueue(q,′h′); enqueue(q,′r′); enqueue(q,y);x = dequeue(q);enqueue(q,x);x = dequeue(q);enqueue(q,′a′);while(!empty(q)){ y = dequeue(q);printf(″%c″,y);}printf(″%c＼n″,x);}10 写一算法将一链队列中的元素依次取出，并打印这些元素值。

实验二堆栈和队列基本操作的编程实现

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY
数据结构
实验报告
实验二堆栈和队列基本操作的编程实现
【实验目的】
堆栈和队列基本操作的编程实现
要求：
堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】
验证性实验（学时数：2H）
【实验内容】
内容：把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。

可以实验一的结果自己实现数据输入、数据显示的函数。

利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。

【注意事项】
1.开发语言：使用C。

2.可以自己增加其他功能。

【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)。

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

实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验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();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。

数据结构实验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<<"种摆放方法。

栈的入队和出队例题

栈的入队和出队例题
栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。

因此，栈的入队和出队操作并不是栈的常规操作，而是队列的操作。

下面我将给出一个例题，演示栈的入队和出队操作。

假设我们有一个栈，初始为空。

现在有一系列操作，其中包括入队和出队操作。

我们按照以下顺序进行操作：
1. 入队操作，将元素A、B、C、D依次入队。

2. 出队操作，出队一个元素。

3. 再次入队操作，将元素E入队。

4. 再次出队操作，出队一个元素。

根据上述操作序列，我们可以得到以下步骤：
1. 初始栈为空。

2. 入队操作，将元素A入栈，栈中元素为A。

3. 入队操作，将元素B入栈，栈中元素为B、A。

4. 入队操作，将元素C入栈，栈中元素为C、B、A。

5. 入队操作，将元素D入栈，栈中元素为D、C、B、A。

6. 出队操作，出栈一个元素，栈中元素为C、B、A，出队的元素为D。

7. 再次入队操作，将元素E入栈，栈中元素为E、C、B、A。

8. 再次出队操作，出栈一个元素，栈中元素为C、B、A，出队的元素为E。

通过上述操作，我们可以得到栈中的元素为C、B、A，按照出队操作的顺序，依次出队的元素为D和E。

需要注意的是，栈的入队和出队操作并不是栈的常规操作，因
为栈是后进先出的，而队列是先进先出的。

在实际应用中，我们通常使用队列来实现队列的入队和出队操作，而不是使用栈。

实验二栈与队列操作实验题目

实验二栈与队列操作实验题目实验二栈与队列操作实验目的：(1)理解栈与队列的结构特征和运算特征，以便在实际问题背景下灵活运用。

(2)了解复杂问题的递归算法设计。

本次实验中，下列实验项目选做一。

1、顺序栈的基本操作[问题描述]设计算法，实现顺序栈的各种基本操作[基本要求]（1）初始化栈s。

（2）从键盘输入10个字符以$结束，建立顺序栈。

（3）从键盘输入1个元素，执行入栈操作。

（4）将栈顶元素出栈。

（5）判断栈是否为空。

（6）输出从栈顶到栈底元素。

要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。

2、链栈的基本操作[问题描述]设计算法，实现链栈的各种基本操作[基本要求]（1）初始化栈s。

（2）从键盘输入10个字符以$结束，建立带头结点的链栈。

（3）从键盘输入1个元素，执行入栈操作。

（4）完成出栈操作。

（5）判断栈是否为空。

（6）输出从栈顶到栈底元素。

（7）输出链栈的长度。

要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。

3、循环队列的基本操作[问题描述]设计算法，实现循环顺序队列的建立、入队、出队等操作。

[基本要求]（1）从键盘输入10个字符以$结束，建立循环队列，并显示结果。

（2）从键盘输入1个元素，执行入队操作，并显示结果。

（3）将队头元素出队，并显示结果。

（4）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。

4、只用尾指针表示的循环链表队列的综合操作[问题描述]假设以带头结点的的循环链表表示队列，并且只设一个指针指向队尾元素的结点（注意不设头指针），试编写队列初始化、入队、出队函数。

[基本要求及提示]（1）首先定义链表结点类型。

（2）编写带头结点的循环链表的初始化函数，只用尾指针表示。

（3）编写入队函数、出队函数。

（4）在主函数中编写菜单（1.初始化；2.入队；3.出队；4.退出），调用上述功能函数。

(完整word版)栈和队列练习

栈和队列一、选择题1 、一个栈的输入序列为： a ， b ， c ， d ， e ，则栈的不可能输出的序列是（C ）。

A. a,b,c,d,eB. d,e,c,b,aC. d,c,e,a,bD. e,d,c,b,a2 、判断一个循环队列 Q （最多 n 个元素）为满的条件是（C ）。

A. Q->rear==Q->frontB. Q->rear==Q->front+1C. Q->front==(Q->rear+1)%nD. Q->front==(Q->rear-1)%n3 、设计一个判别表达式中括号是否配对的算法，采用（D）数据结构最佳。

A. 顺序表B.链表C. 队列D. 栈4 、5 、一个栈的输入序列为：1,2,3,4，则栈的不可能输出的序列是（D ）。

A. 1243B. 2134C. 1432D. 4312E. 32146 、若用一个大小为 6 的数组来实现循环队列，且当 rear 列中删除一个元素，再加入两个元素后，rear 和 front和5和4和2和 front 的值分别为 0 ， 3。

当从队的值分别为（ B）。

和17 、队列的插入操作是在（A）。

A. 队尾B. 队头C.8 、循环队列的队头和队尾指针分别为（A）。

队列任意位置front和 rear D. 队头元素后，则判断循环队列为空的条件是A. front==rearB. front==0C. rear==0D. front=rear+19 、一个顺序栈 S ，其栈顶指针为 A. *S->top=e;S->top++;top ，则将元素 e 入栈的操作是（AB. S->top++;*S->top=e;）。

C. *S->top=eD. S->top=e;10 、表达式a*(b+c)-d的后缀表达式是（B）。

A. abcd+-B. abc+*d-C. abc*+d-D. -+*abcd 11 、将递归算法转换成对应的非递归算法时，通常需要使用（A. 队列B. 栈C. 链表B ）来保存中间结果。

数据结构试验：栈和队列实验——表达式求值

实验报告课程名称数据结构实验项目实验二--栈和队列实验系别___ _计算机学院 _ ______专业___ _计算机科学与技术___班级/学号__学生姓名 ____________实验日期成绩_______________________指导教师实验题目：实验二-----栈和队列实验一、实验目的1)掌握栈的顺序存储结构及队列的链式存储结构；2)验证栈的顺序存储结构的操作的实现；3)验证队列的链式存储结构的操作的实现；4)理解算法与程序的关系，能够将算法转换为对应程序。

二、实验内容1)建立一个顺序存储的空栈，并以此分别实现入栈、出栈、取栈顶元素；2)建立一个链式结构的空队列，并以此分别实现入队、出队、取队头等基本操作；3)尝试利用栈和队列的算法解决一些实际的应用问题。

设计与编码1)实验题目主要需求说明2)设计型题目：表达式求值（要求利用栈结构和运算符优先约定表，输入一个表达式，并计算求值）3)结合题目，说明利用栈或队列解决问题的基本算法描述4)程序源码#include<iostream>using namespace std;const int InitSize=100;const int IncreastSize=10;template<class datatype>class SqStack {private:datatype *base;datatype *top;int stacksize;public:SqStack();void DestroyStack();void ClearStack();int StackLength();bool IsEmpty();bool GetTop(datatype &e);bool Pop(datatype &e);bool Push(datatype e);};template<class datatype>SqStack<datatype>::SqStack(){base=new datatype[InitSize];if(!base)exit(1);top=base;stacksize=InitSize;}template<class datatype>void SqStack<datatype>::DestroyStack() {delete[] base;base=top=NULL;stacksize=0;}template<class datatype>void SqStack<datatype>::ClearStack() {top=base;}template<class datatype>int SqStack<datatype>::StackLength() {return top-base;}template<class datatype>bool SqStack<datatype>::IsEmpty() {if(top==base)return fasle;else return true;}template<class datatype>bool SqStack<datatype>::GetTop(datatype &e){if(top==base)return false;e=*(top-1);return true;}template<class datatype>bool SqStack<datatype>::Pop(datatype &e){if(top==base)return false;e=*(top-1);top--;return true;}template<class datatype>bool SqStack<datatype>::Push(datatype e){if(top-base>=stacksize){base=(datatype *)realloc( base , (stacksize+IncreastSize)*sizeof(int) ); if(!base)exit(1);top=base+stacksize;stacksize+=IncreastSize;}*(top)=e;top++;return true;}int com(char m,char t){if(t=='(') return -1;else if(t==')'){if(m=='+'||m=='-'||m=='*'||m=='/') return 1; else if(m=='(') return 0;else return -2;}else if(t=='*'||t=='/'){if(m=='+'||m=='-'||m=='#'||m=='(') return -1; else return 1;}else if(t=='+'||t=='-'){if(m=='#'||m=='(') return -1;else return 1;}else{if(m=='#')return 0;else if(m=='+'||m=='-'||m=='*'||m=='/') return 1; else return -2;}}void main(){SqStack <char> op;SqStack <double> re;char t,m;double result,flag=1;op.Push('#');t=getchar();while(true){if(t>='0'&&t<='9'){double s=0;s=s*10+t-'0';t=getchar();while(t>='0'&&t<='9' ){s=s*10+t-'0';t=getchar();}re.Push(s);}else if(t=='+'||t=='-'||t=='*'||t=='/'||t=='('||t==')'||t=='\n') { op.GetTop(m);while(com(m,t)==1 ){double x1,x2;op.Pop(m);if(re.Pop(x2)&&re.Pop(x1)){if(m=='+') re.Push(x1+x2);else if(m=='-') re.Push(x1-x2);else if(m=='*') re.Push(x1*x2);else if(m=='/') {if(x2!=0)re.Push(x1/x2); else flag=0;} }else flag=0;op.GetTop(m);}if(com(m,t)==-1)op.Push(t);else if(com(m,t)==0)op.Pop(m);else flag=0;if(!op.GetTop(m)) break;t=getchar();}else t=getchar();}if(re.GetTop(result)&&flag)cout<<result<<endl;else cout<<"Input error!\n";}5)运行结果三、总结与心得。

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

2007级数据结构实验报告实验名称：实验二栈和队列日期：2008年11月15日1．实验要求实验目的通过选择下面五个题目之一进行实现，掌握如下内容：进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力实验内容2.1题目1根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。

要求：1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。

2. 程序分析2.1 存储结构存储结构：特殊线性表：栈，队列栈顶栈底链栈2.2 关键算法分析共享栈的入栈算法伪码（Push ）： 1．如果栈满，抛出上溢异常。

2．判断是插在栈1还是栈2：2.1如果在栈1插入，则栈顶指针top1加1，在top1处填入元素x ； 2.2如果在栈2插入，则栈顶指针top2加1，在top2处填入元素x 。

共享栈的出栈算法伪码（Pop ）：1. 判断是在栈1删除还是在栈2删除。

2. 若是在栈1删除，则2.1 若栈1为空栈，抛出下溢异常； 2.2 删除并返回栈1的栈顶元素；3. 若是在栈2删除，则3.1 若栈2为空栈，抛出下溢异常； 3.2 删除并返回栈2的栈顶元素。

非空链队列空链队列共享栈的取栈顶元素算法伪码（GetTop）：1．判断是在栈1取还是栈2取；2．如果在栈1取，则2.1 若栈1不空，返回栈顶元素的值，不删除；2.2 若栈1空，返回0；3．如果在栈2取，则3.1 若栈2不空，返回栈顶元素的值，不删除；3.2 若栈2空，返回0。

链栈的入栈算法伪码（Push）：1．申请一个新的结点，数据域为x；2．将新结点插在栈顶；3．栈顶指针重新指向栈顶元素。

链栈的出栈算法伪码（Pop）：1．如果栈空，抛出下溢异常；2．暂存栈顶元素；3．将栈顶结点摘链；4．删除该结点，返回该元素的值。

链栈的取栈顶元素算法的伪码（GetTop）：1．如果栈非空，返回栈顶元素的值，不删除。

栈和队列习题及答案

栈和队列习题及答案栈和队列习题及答案【篇一：栈和队列练习题答案】xt>一、填空题1. 线性表、栈和队列都是结构，可以在线性表的在栈顶插入和删除元素；对于队列只能在队尾插入和队首删除元素。

2. 栈是一种特殊的线性表，允许插入和删除运算的一端称为。

不允许插入和删除运算的一端称为栈底。

3. 是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。

二、判断正误（√）1. 栈是一种对所有插入、删除操作限于在表的一端进行的线性表，是一种后进先出型结构。

（√）2. 对于不同的使用者，一个表结构既可以是栈，也可以是队列，也可以是线性表。

正确，都是线性逻辑结构，栈和队列其实是特殊的线性表，对运算的定义略有不同而已。

错，他们都是线性逻辑结构，栈和队列其实是特殊的线性表，对运算的定义略有不同而已。

（√）4. 栈和队列的存储方式既可是顺序方式，也可是链接方式。

（√）5. 两个栈共享一片连续内存空间时，为提高内存利用率，减少溢出机会，应把两个栈的栈底分别设在这片内存空间的两端。

错，有可能。

三、单项选择题（b）1.栈中元素的进出原则是Ａ．先进先出Ｂ．后进先出Ｃ．栈空则进Ｄ．栈满则出（c）2.若已知一个栈的入栈序列是1，2，3，?，n，其输出序列为p1，p2，p3，?，pn，若p1=n，则pi为Ａ．i Ｂ．n-iＣ．n-i+1 Ｄ．不确定解释：当p1=n，即n是最先出栈的，根据栈的原理，n必定是最后入栈的（事实上题目已经表明了），那么输入顺序必定是1，2，3，?，n，则出栈的序列是n，?，3，2，1。

（若不要求顺序出栈，则输出序列不确定）（d）3．数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素的公式为（Ａ）r－f; （Ｂ）（n＋f－r）% n; （Ｃ）n＋r－f;（Ｄ）（n＋r －f）% n e：①1 ②2 ③ 3 ④ 0四、阅读理解1. 【严题集3.3②】写出下列程序段的输出结果（栈的元素类型selem type为char）。

栈、队列练习题(答案)

栈、队列练习题一、选择题1.栈和队列的共同特点是( )。

A.只允许在端点处插入和删除元素B.都是先进后出C.都是先进先出D.没有共同点2.若让元素1、2、3、4依次入栈，则出栈次序不可能出现（）A．3 2 1 4 B．2 1 4 3 C．1 4 2 3 D．4 3 2 13.栈的插入和删除操作在( )进行。

A. 栈顶B. 栈底C. 任意位置D. 指定位置4.用单链表表示的链式队列的队头在链表的（）位置。

A. 链头B. 链尾C. 链中D. 以上都不是5.在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是（）。

A． p->next=s; s->prior=p;p->next->prior=s; s->next=p->next;B． s->prior=p; s->next=p->next;p->next=s; p->next->prior=s;C． p->next=s; p->next->prior=s;s->prior=p; s->next=p->next;D． s->prior=p; s->next=p->next;p->next->prior=s; p->next=s;6.设有一个栈，元素的进栈次序为A, B, C, D, E,下列是不可能的出栈序列( )。

A．A, B, C, D, E B．B, C, D, E, AC．E, A, B, C, D D．E, D, C, B, A7.在一个具有n个单元的顺序栈中，假定以地址低端（即0单元）作为栈底，以top作为栈顶指针，当做出栈处理时，top变化为( )。

A．top不变B．top=0 C．top-- D．top++8.向一个栈顶指针为hs的链栈中插入一个s结点时，应执行( )。

A．hs->next=s;B．s->next=hs; hs=s;C．s->next=hs->next;hs->next=s;D．s->next=hs; hs=hs->next;9.在具有n个单元的顺序存储的循环队列中，假定front和rear分别为队头指针和队尾指针，则判断队满的条件为( )。

实验2_栈与队列的应用

实验二：栈与队列的应用学时：4学时实验目的：掌握栈与队列的基本结构和操作方法，并能利用其解决实际问题。

实验内容： (任选一题，有能力的同学可以两题都做)一、输入一个表达式(4+2*4#),利用栈求表达式的值。

（只对整数求值，目前只考虑操作数为个位数的情况，即24+34*34这种情况不考虑）提示：1，先实现栈的基本操作：初始化，入栈，出栈等。

2，首先将一个中缀式变成后缀式，然后，对后缀式求值。

3，可用顺序栈或者链栈实现。

二、编写一个程序，反映病人到医院看病排队看医生的情况，在病人排队过程中，主要重复两件事：（1）病人到达诊室，将病历交给护士，排到等待队列中侯诊（2）护士从等待队列中取出下一位病人的病历，改病人进入诊室就诊要求：模拟病人等待就诊这一过程，程序采用菜单式，其选项和功能说明如下：（1）排队——输入排队病人的病历号，加入到病人排队队列中（2）就诊——病人排队队列中最前面的病人就诊，将其从队列中删除（3）查看排队——从队首到队尾理出所有的排队病人的病历号（4）不在排队，余下依次就诊——从队首到队尾列出所有的排队病人的病历号，并退出运行（5）下班——退出运行（6）上班——初始化排队队列。

提示：1，先实现队列的基本操作：初始化，入队，出队等。

2，在main（）程序中，模拟病人看病这个过程。

给出菜单选择，进行相应的操作3，可用顺序队列或者链队列实现。

可参考如下代码：顺序栈的实现ch32_sstack.c#include "stdio.h"#define StackSize 100typedef int ElemType;typedef struct {ElemType elem[StackSize];int top;}SqStack;InitStack(SqStack *pS){pS->top=0; /* top指向栈顶的上一个元素*/}int Push(SqStack *pS,ElemType e){if (pS->top==StackSize-1) /* 栈满*/return 0;pS->elem[pS->top]=e;pS->top=pS->top+1;return 1;}int Pop(SqStack *pS,ElemType* pe){if (pS->top==0) /* 栈空*/return 0;pS->top = pS->top - 1;*pe = pS->elem[pS->top];return 1;}main(){SqStack S;ElemType e;int N;InitStack(&S);N=1348;while(N){e = N % 8;Push(&S,e);N = N/8;}while(Pop(&S,&e)){printf("%d",e);}getch();}链栈的实现ch3_lstack.c #include "stdio.h"/* 数据元素的类型*/typedef int ElemType;/* 节点的类型（包括头节点）*/typedef struct Node{ElemType elem;struct Node *next;}SNode;/* 初始化，头节点*/InitStack(SNode* pS){pS->next=NULL;}/* 入栈：在头节点之后插入一个新节点*/Push(SNode* pS,ElemType e){SNode* node;node = (SNode*)malloc(sizeof(SNode));node->elem = e;node->next = pS->next;pS->next = node;}int Pop(SNode* pS,ElemType* pe){SNode* node;if (pS->next==NULL){return 0;}*pe = pS->next->elem;node=pS->next;pS->next=node->next;free(node);return 1;}main(){SNode S; ElemType e;int N;InitStack(&S);N=1348;while(N){e = N % 8;Push(&S,e);N = N/8;}while(Pop(&S,&e)){printf("%d",e);}getch();}队列的顺序实现（循环队列）ch3_squeue.c/*队列的顺序实现（循环队列）author: Shirleydate: 2011.3*/#define MaxSize 100typedef int ElemType;typedef struct {ElemType elem[MaxSize];int front,rear;}SqQueue;InitQueue(SqQueue* pQ){pQ->front=pQ->rear=0;}int EnQueue(SqQueue* pQ,ElemType e){if ((pQ->rear+1)%MaxSize == pQ->front) /* 队满*/ return 0;pQ->elem[pQ->rear] = e;pQ->rear = (pQ->rear+1)%MaxSize;return 1;}int DeQueue(SqQueue* pQ,ElemType* pe){if (pQ->rear == pQ->front) /* 队空*/return 0;*pe = pQ->elem[pQ->front];pQ->front = (pQ->front+1)%MaxSize;return 1;}main(){SqQueue Q;ElemType e;InitQueue(&Q);e=2;EnQueue(&Q,e);e=5;EnQueue(&Q,e);e=3;EnQueue(&Q,e);while(DeQueue(&Q,&e)){printf("\n%d",e);}getch();}队列的链式实现ch3_lqueue.c /*队列的链式实现author: Shirleydate: 2011.3*/#include "stdio.h"#define MaxSize 100typedef int ElemType;typedef struct QNode{ElemType elem;struct QNode * next;}QNode;typedef struct {QNode* front;QNode* rear;}LinkQueue;InitQueue(LinkQueue* pQ){QNode* node;node=(QNode*)malloc(sizeof(QNode)); /*分配一个头节点*/ node->next = NULL;pQ->front=pQ->rear=node;}int EnQueue(LinkQueue* pQ,ElemType e){QNode* node;node=(QNode*)malloc(sizeof(QNode));node->elem = e;node->next = NULL;pQ->rear->next = node;pQ->rear = node;return 1;}int DeQueue(LinkQueue* pQ,ElemType* pe){QNode* node;if (pQ->rear == pQ->front) /* 队空*/return 0;node = pQ->front->next;*pe = node->elem;pQ->front->next = node->next;/* 注意有个头节点，当最后一个元素出队时，记得更新尾指针*/ if (pQ->rear==node)pQ->rear=pQ->front;free(node);return 1;}DestoryQueue(LinkQueue* pQ){while(pQ->front){pQ->rear=pQ->front->next;free(pQ->front);pQ->front = pQ->rear;}}main(){LinkQueue Q;ElemType e;InitQueue(&Q);e=2;EnQueue(&Q,e);e=5;EnQueue(&Q,e);e=3;EnQueue(&Q,e);while(DeQueue(&Q,&e)){printf("\n%d",e);}DestoryQueue(&Q);getch();}。

栈队列测试[试题]

栈和队列测试题一、判断1.队列中所有的插入操作都发生在表的一端，删除则发生在表的另一端2.栈具有先进先出的特性3.队列为先进后出的结构4.栈用于实现子程序调用5.栈、队列必须用数组来表示6.队列用于操作系统中的作业调度7.线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。

8.栈和链表是两种不同的数据结构。

9.栈和队列的存储方式既可是顺序方式，也可是链接方式。

二、单项选择1．循环队列用数组A[maxsize] 表示，下面哪个选项表示该循环队列队满(A) rear==maxsize-1 (B) front==(rear+1)%maxsize(C) rear-front==maxsize (D) rear-front==maxsize-12．元素的入栈序列是a,b,c,d，则栈的不可能的输出序列是(A) dcba (B)abcd (C) dcab (D) cbad3．链表仿真堆栈时，栈空的条件是(A) top<maxsize-1 (B) top==NULL (C) 没有限制 (D) top<04．在用数组queue[maxsize]仿真队列时(temp为int型变量)，假设队列中至少有一个元素，出队列操作应执行以下(A) temp=queue[rear]；rear--； (B) rear++； temp=queue[rear]；(C) temp=queue[front]；front--； (D) front++； temp=queue[front]；5．在用链表仿真堆栈时(假设stack为栈顶指针)，将new指针指向的节点执行入栈操作应执行(A) new->next=stack->next； stack=new； (B) new->next=stack； stack=new；(C)new->next=stack；stack=new->next；(D) stack=new；stack->next=new->next；6．链表仿真堆栈时，栈满的条件是(A) top<maxsize-1 (B) top==NULL (C) 没有限制 (D) top<07．下列哪种数据结构常用于函数调用(A) 堆栈 (B) 队列 (C) 链表 (D) 数组8．编译器中通常以哪种数据结构处理递归程序调用（A）队列（B）数组（C）堆栈（D）记录9．下列哪些数据结构可用来实现堆栈（1）链表（2）数组（3）树（4）图（A）（2），（3）（B）（2），（4）（C）（1），（4）（D）（1），（2）10．下列哪种数据结构常用于系统程序的作业调度（A）栈（B）队列（C）链表（D）数组11．栈和队列的共同点是（A）都是先进后出（B）都是先进先出（C）只允许在端点处插入和删除元素（D）没有共同点12．若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为Ａ．i Ｂ．n=i Ｃ．n-i+1 Ｄ．不确定13．判定一个栈ST（最多元素为m0）为空的条件是Ａ．ST->top<>0 Ｂ．ST->top=0 Ｃ．ST->top<>m0 Ｄ．ST->top=m014．数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素的公式为（Ａ）r－f; （Ｂ）（n＋f－r）% n; （Ｃ）n＋r－f （Ｄ）（n＋r－f）% n15．用单链表表示的链式队列的队头在链表的位置(A)链头(B)链尾(C)链中16．在解决计算机主机与打印机之间速度不匹配问题时通常设置一个打印数据缓冲区,主机将要输出的数据依次写入该缓冲区,而打印机则从该缓冲区中取出数据打印.该缓冲区应该是一个结构.(A)堆栈(B)队列(C)数组(D)线性表17、判断一个队列QU（最多元素为m0）为空的条件是。

栈与队列习题参考附标准答案

习题三参考答案备注: 红色字体标明的是与书本内容有改动的内容。

一、选择题1.在栈中存取数据的原则是（ B ）。

A．先进先出 B. 先进后出C. 后进后出D. 没有限制2．若将整数1、2、3、4依次进栈，则不可能得到的出栈序列是（ D ）。

A．1234 B. 1324 C. 4321 D. 14233．在链栈中，进行出栈操作时（B ）。

A．需要判断栈是否满 B. 需要判断栈是否为空C. 需要判断栈元素的类型D. 无需对栈作任何差别4．在顺序栈中，若栈顶指针top指向栈顶元素的下一个存储单元，且顺序栈的最大容量是maxSize，则顺序栈的判空条件是（ A ）。

A．top==0 B.top==-1 C. top==maxSize D.top==maxSize-15．在顺序栈中，若栈顶指针top指向栈顶元素的下一个存储单元，且顺序栈的最大容量是maxSize。

则顺序栈的判满的条件是（ C ）。

A．top==0 B.top==-1 C. top==maxSize D.top==maxSize-16．在队列中存取数据元素的原则是（ A ）。

A．先进先出 B. 先进后出C. 后进后出D. 没有限制7．在循环顺序队列中，假设以少用一个存储单元的方法来区分队列判满和判空的条件，front 和rear分别为队首和队尾指针，它们分别指向队首元素和队尾元素的下一个存储单元，队列的最大存储容量为maxSize，则队列的判空条件是（A ）。

A．front==rear B. front!=rearC. front==rear+1D. front==(rear+1)% maxSize8．在循环顺序队列中，假设以少用一个存储单元的方法来区分队列判满和判空的条件，front 和rear分别为队首和队尾指针，它们分别指向队首元素和队尾元素的下一个存储单元，队列的最大存储容量为maxSize，则队列的判满条件是（D ）。

A．front==rear B. front!=rearC. front==rear+1D. front==(rear+1)% maxSize9.在循环顺序队列中，假设以少用一个存储单元的方法来区分队列判满和判空的条件，front和rear分别为队首和队尾指针，它们分别指向队首元素和队尾元素的下一个存储单元，队列的最大存储容量为maxSize，则队列的长度是（C ）。

数据结构栈和队列作业.doc

1.实验目的：熟练掌握栈和队列的存储结构设计及基本操作的实现；学会分析实际问题中具有栈特点的数据结构；了解表达式的前缀、中缀、后缀等计算机内表示形式。

2.实验内容与要求：按常规形式输入算术表达式（例如：输入2*(6-4)+8/4），要求能够：（1）生成表达式的后缀表示，并输出；（2）生成表达式的前缀表示，并输出；（3）基于表达式的后缀表示，对该表达式求值；（4）编写一个主程序对表达式求值函数进行测试。

3.数据结构设计：逻辑结构：线性结构存储结构：顺序存储结构4.算法设计：#include <stdio.h>#include <windows.h>#define MaxSize 100#define Maxop 7//定义栈typedef struct{char data[MaxSize];int top;}SeqStack;//构造运算符优先级的表格struct{char ch;int pri;}lpri[]={ {'(',1},{'*',5},{'/',5},{'+',3},{'-',3},{')', 6},{'#',-1} },rpri[]={ {'(',6},{'*',4},{'/',4},{'+',2},{'-',2},{')', 1}};//查找左边运算符的优先级int leftpri(char op){int i;for (i = 0 ; i < Maxop ; i++)if (lpri[i].ch == op )return lpri[i].pri;}//查找右边运算符的优先级int rightpri(char op) {int i;for (i = 0 ; i < Maxop-1 ; i++)if (rpri[i].ch == op )return rpri[i].pri;}//判断是否为运算符int InOp(char ch){if (ch == '(' || ch == ')' || ch == '+' || ch == '-' || ch == '*' || ch == '/' )return 1;elsereturn 0;}//比较左右运算符大小的函数int Precede(char op1,char op2){if( leftpri(op1) == rightpri(op2) )return 0;else if( leftpri(op1)<rightpri(op2) )return -1;elsereturn 1;}//将中序表达式转换为后续表达式的函数void trans( char *exp,char postexp[] ){//这里定义的是存放运算符的栈struct{char data[MaxSize];int top;}op;//初始化存放运算符的栈int i = 0;op.top = -1;op.top++;op.data[op.top] = '#';//开始进行转换while(*exp != '\0'){//如果不是运算符if( !InOp(*exp) ){//只要是0~9，就一直循环将数字移动到//postexp[]中while( *exp >= '0' && *exp <= '9'){postexp[i++] = *exp;exp++;}//为了区分超过9的数字//使用#作为分隔符postexp[i++] = '#';}//如果是运算符else//比较栈内的运算符和表达式中的运算符switch( Precede(op.data[op.top],*exp) ) {//如果栈中小运算符入栈case -1:op.top++;op.data[op.top] = *exp;exp++;break;//如果是括号就相消case 0:op.top--;exp++;break;//如果栈中大运算符就出栈放到//postexp[]中case 1:postexp[i++] =op.data[op.top];op.top--;break;}}//当表达式遍历后将符号栈中的一切//放到postexp[]中while( op.data[op.top] != '#' ){postexp[i++] = op.data[op.top];op.top--;}postexp[i] = '\0';}//以下几个函数来自栈的基本操作void PUSH(SeqStack *s,char x){s->top++;s->data[s->top]=x ;}int Sempty(SeqStack *s){if (s->top == -1) return 1;else return 0;}char POP(SeqStack *s){s->top--;return s->data[s->top+1];}void SETNULL(SeqStack *s){s->top = -1;}//这个是转换函数,用于谦虚表达式void reverse(char exp[],char demoexp[]) {void PUSH(SeqStack *s,char x);int Sempty(SeqStack *s);char POP(SeqStack *s);void SETNULL(SeqStack *s);int Sempty(SeqStack *s);//这里有点乱解释下//s是存放数据的栈,这样为了//避免超过9的数在运算的时候乱掉//sp是存放整个表达式的栈//最后将整个表达式逆置SeqStack *s,*sp;int strling,i,j;j = strlen(exp);s = (SeqStack*)malloc(20*sizeof(SeqStack) );sp = (SeqStack*)malloc(50*sizeof(SeqStack) );SETNULL(s);SETNULL(sp);strling = strlen(exp) - 1;for(i = 0 ; i < j ; ){//如果是数字的话先入s栈if(exp[i] >='0' && exp[i] <='9'){while(exp[i] >='0' && exp[i] <='9'){PUSH(s,exp[i]);i++;}//如果扫描下一个字符不是数字了,就//将数字全部放到sp栈中while( !Sempty(s) ){PUSH( sp, POP(s) );}}//如果不是数字的话直接放到sp栈中else{PUSH(sp , exp[i]);i++;}}i = 0;//退栈放到demoexp[]中while(!Sempty(sp)){demoexp[i] = POP(sp);i++;}demoexp[i] = '\0';//逆置之后将括号改回来for(i = 0 ; i < j ; i ++){if(demoexp[i] == ')')demoexp[i] = '(';else if(demoexp[i] == '(')demoexp[i] = ')';}demoexp[j] = '\0';}//利用后序表达式求解的函数float compvalue(char *postexp){//定义数据栈struct{float data[MaxSize];int top;}st;float a,b,c,d;st.top = -1;//如果后序表达式没结束while( *postexp != '\0' ){switch( *postexp ){//如果是加,取数据栈中的两个数//进行运算再放回去,下同case '+':a = st.data[st.top];st.top--;b = st.data[st.top];st.top--;c = a + b;st.top++;st.data[st.top] = c;break;case '-':a = st.data[st.top];st.top--;b = st.data[st.top];st.top--;c = b - a;st.top++;st.data[st.top] = c;break;case '*':a = st.data[st.top];st.top--;b = st.data[st.top];st.top--;c = b * a;st.top++;st.data[st.top] = c;break;case '/':a = st.data[st.top];st.top--;b = st.data[st.top];st.top--;if( a != 0 ){c = b / a;st.top++;st.data[st.top] = c;}//除零错误else{printf( "\noverflow\n" );exit(0);}break;//#就直接忽略case '#':break;//如果是数字的话,字符转数字然后放到数据栈中default:d = 0;while(*postexp >= '0' && *postexp <= '9'){d = 10 *d + *postexp - '0';postexp++;}st.top++;st.data[st.top] = d;break;}postexp++;}return (st.data[st.top]);}//这个是去掉表达式中的"#"void convert(char *postexp,char *postexptail) {int i=0,j=0;while(postexp[i] != '\0'){if(postexp[i] != '#'){postexptail[j] = postexp[i];i++;j++;}else i++;}postexptail[j] = '\0';}void main(){int i;char exp[MaxSize];char postexptail[MaxSize];char postexp[MaxSize];char preexp[MaxSize];char demoexp[MaxSize];printf("请选择运算数是否大于9\n");printf("1.不大于9\n");printf("2.大于9\n");do{scanf("%d",&i);if(i > 2 || i < 1 )printf("输入错误,请重新输入\n");}while(i > 2 || i < 1);getchar();printf("请输入中序表达式，以回车键结束\n");gets(exp);trans(exp,postexp);printf("中序表达式%s\n",exp);switch(i){case 1:convert(postexp,postexptail);printf("后序表达式%s\n",postexptail);break;case 2:printf("后序表达式%s\n",postexp);break;}//这里解释下,在进行了多次试验发现前序表达式//可以通过逆置中序表达式然后再进行后序转化//然后再逆置一次就可以得到前序表达式switch(i){case 1:reverse(exp,demoexp);trans(demoexp,preexp);reverse(preexp,demoexp);convert(demoexp,preexp);printf("前序表达式%s\n",preexp);break;case 2:reverse(exp,demoexp);trans(demoexp,preexp);reverse(preexp,demoexp);printf("前序表达式%s\n",demoexp);break;}printf("所求值为%g\n",compvalue(postexp));getchar();}5.实验结果：。

实验二 栈与队列操作实验题目

实验二 栈和队列的基本操作实现及其应用

栈和队列习题

数据结构栈和队列习题及答案

天大数据结构_实验作业二_栈(顺序栈)+队列(循环队列)

数据结构练习题栈和队列

实验二 堆栈和队列基本操作的编程实现

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

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

栈的入队和出队例题

实验二栈与队列操作实验题目

(完整word版)栈和队列练习

数据结构试验：栈和队列实验——表达式求值

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

栈和队列习题及答案

栈、队列练习题(答案)

实验2_栈与队列的应用

栈队列测试[试题]

栈与队列习题参考附标准答案

数据结构栈和队列作业.doc

实验二栈与队列操作实验题目

实验二栈和队列的基本操作实现及其应用

实验二堆栈和队列基本操作的编程实现

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