作业2栈和队列数组参考答案

栈和队列习题答案

第三章栈和队列习题答案一、基础知识题设将整数1，2，3，4依次进栈，但只要出栈时栈非空，则可将出栈操作按任何次序夹入其中，请回答下述问题：(1)若入、出栈次序为Push(1), Pop(),Push(2),Push(3), Pop(), Pop( ),Push(4), Pop( ),则出栈的数字序列为何(这里Push(i)表示i进栈，Pop( )表示出栈)(2)能否得到出栈序列1423和1432并说明为什么不能得到或者如何得到。

(3)请分析1，2 ，3 ，4 的24种排列中，哪些序列是可以通过相应的入出栈操作得到的。

答：(1)出栈序列为：1324(2)不能得到1423序列。

因为要得到14的出栈序列，则应做Push(1),Pop(),Push(2),Push(3),Push(4),Pop()。

这样，3在栈顶，2在栈底，所以不能得到23的出栈序列。

能得到1432的出栈序列。

具体操作为：Push(1), Pop(),Push(2),Push(3),Push(4),Pop(),Pop(),Pop()。

(3)在1，2 ，3 ，4 的24种排列中，可通过相应入出栈操作得到的序列是：1234,1243,1324,1342,1432,2134,2143,2314,2341,2431,3214,3241,3421,4321不能得到的序列是：1423,2413,3124,3142,3412,4123,4132,4213,4231,4312链栈中为何不设置头结点答：链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要对头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。

循环队列的优点是什么如何判别它的空和满答：循环队列的优点是：它可以克服顺序队列的"假上溢"现象，能够使存储队列的向量空间得到充分的利用。

判别循环队列的"空"或"满"不能以头尾指针是否相等来确定，一般是通过以下几种方法：一是另设一布尔变量来区别队列的空和满。

栈和队列答案

栈和队列一选择题1. 对于栈操作数据的原则是（）。

A. 先进先出B. 后进先出C. 后进后出D. 不分顺序2. 在作进栈运算时,应先判别栈是否( ①B ),在作退栈运算时应先判别栈是否( ②A)。

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

为了增加内存空间的利用率和减少溢出的可能性,由两个栈共享一片连续的内存空间时,应将两栈的( ④ )分别设在这片内存空间的两端,这样,当( ⑤ )时，才产生上溢。

①, ②: A. 空 B. 满 C. 上溢 D. 下溢③: A. n-1 B. n C. n+1 D. n/2④: A. 长度 B. 深度 C. 栈顶D. 栈底⑤: A. 两个栈的栈顶同时到达栈空间的中心点.B. 其中一个栈的栈顶到达栈空间的中心点.C. 两个栈的栈顶在栈空间的某一位置相遇.D. 两个栈均不空,且一个栈的栈顶到达另一个栈的栈底.3. 一个栈的输入序列为123…n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（）。

A. 不确定B. n-i+1C. iD. n-i4. 若一个栈的输入序列为1,2,3,…,n，输出序列的第一个元素是i，则第j 个输出元素是（）。

A. i-j-1B. i-jC. j-i+1D. 不确定的5. 若已知一个栈的入栈序列是1,2,3,…,n，其输出序列为p1,p2,p3，…，pN,若pN 是n，则pi 是( )。

A. iB. n-iC. n-i+1D. 不确定6. 有六个元素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 67. 设栈的输入序列是1，2，3，4,则（）不可能是其出栈序列。

A. 1，2，4，3，B. 2，1，3，4，C. 1，4，3，2，D. 4，3，1，2，E. 3，2，1，4，8. 一个栈的输入序列为1 2 3 4 5，则下列序列中不可能是栈的输出序列的是（）。

栈和队列参考答案

int Check( ) { SqStack S; char ch1, ch2; InitStack(&S); ch1=getchar(); while(ch1!=‘&’ && ch1!=’@’) { Push(&S, ch1); ch1=getchar(); } while(ch1!=‘@’) { ch1=getchar(); Pop(&S, &ch2); if(ch1!=ch2) break; } if(ch1==‘@’ && StackEmpty(&S)) return 1; else return 0; }
参考答案：参考答案：
#define MAXSIZE 6 #define OK 1 #define ERROR 0 typedef int elemType; typedef struct { elemType a[MAXSIZE]; int rear,length; }cycleque;
void InitQueue(cycleque *p) { p->rear=p->length=0; } int EnQueue(cycleque *p, elemType e) { if(p->length==MAXSIZE) //队列满队列满 return ERROR; p->rear=(p->rear+1)%MAXSIZE; p->a[p->rear]=e; p->length++; return OK; }
int InitQueue(LinkQueue *Q) { Q->rear= (LinkQueueNode *)malloc(sizeof(LinkQueueNode)); if(!Q->rear) return ERROR; Q->rear->next= Q->rear; return TRUE; }

数据结构练习题第三章栈、队列和数组习题及答案

第三章栈、队列和数组一、名词解释：1.栈、栈顶、栈底、栈顶元素、空栈2.顺序栈3.链栈4.递归5.队列、队尾、队头6.顺序队7.循环队8.队满9.链队10.随机存储结构11.特殊矩阵12.稀疏矩阵13.对称方阵14.上（下）三角矩阵二、填空题：1.栈修改的原则是_________或称________，因此，栈又称为________线性表。

在栈顶进行插入运算，被称为________或________，在栈顶进行删除运算，被称为________或________。

2.栈的基本运算至少应包括________、________、________、________、________五种。

3.对于顺序栈，若栈顶下标值top=0,此时，如果作退栈运算，则产生“________”。

4.对于顺序栈而言，在栈满状态下，如果此时在作进栈运算，则会发生“________”。

5.一般地，栈和线性表类似有两种实现方法，即________实现和________实现。

6.top=0表示________，此时作退栈运算，则产生“________”；top=sqstack_maxsize-1表示________，此时作进栈运算，则产生“________”。

7.以下运算实现在顺序栈上的初始化，请在________处用适当的句子予以填充。

int InitStack(SqStackTp *sq){ ________;return(1);}8.以下运算实现在顺序栈上的进栈，请在________处用适当的语句予以填充。

Int Push(SqStackTp *sq,DataType x){ if(sp->top==sqstack_maxsize-1}{error(“栈满”);return(0);}else{________________:________________=x;return(1);}}9.以下运算实现在顺序栈上的退栈，请在________________用适当句子予以填充。

栈、队列练习题（答案）

栈、队列练习题（答案）栈、队列练习题一、选择题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结点时，应执行( )。

数据结构习题参考答案

数据结构习题参考答案一、栈和队列1. 栈是一种具有后进先出（Last In First Out）特性的线性数据结构。

常用方法：- push(x): 将元素x压入栈顶；- pop(): 弹出栈顶元素；- top(): 返回栈顶元素；- isEmpty(): 判断栈是否为空；例题解答：（1）题目描述：使用栈实现队列的功能。

解答：使用两个栈，一个用于入队操作，一个用于出队操作。

入队操作：直接将元素压入入队栈中；出队操作：如果出队栈为空，则将入队栈的元素逐个弹出并压入出队栈，此时出队栈的栈顶元素即为要弹出的元素。

复杂度分析：入队操作的时间复杂度为O(1)，出队操作的平均时间复杂度为O(1)。

（2）题目描述：判断括号序列是否合法，即括号是否完全匹配。

解答：使用栈来处理括号序列，遇到左括号则入栈，遇到右括号则与栈顶元素进行匹配，如果匹配成功则继续处理剩余字符，如果不匹配则判定为非法序列。

算法步骤：- 初始化一个空栈；- 从左到右遍历括号序列，对于每个字符执行以下操作：- 如果是左括号，则将其入栈；- 如果是右括号，则将其与栈顶元素进行匹配：- 如果栈为空，则判定为非法序列；- 如果栈顶元素与当前字符匹配，则将栈顶元素出栈，继续处理剩余字符；- 如果栈顶元素与当前字符不匹配，则判定为非法序列。

- 遍历结束后，如果栈为空，则括号序列合法；否则，括号序列非法。

复杂度分析：时间复杂度为O(n)，其中n为括号序列的长度。

2. 队列是一种具有先进先出（First In First Out）特性的线性数据结构。

常用方法：- enqueue(x): 将元素x入队；- dequeue(): 出队并返回队首元素；- getFront(): 返回队首元素；- isEmpty(): 判断队列是否为空；例题解答：（1）题目描述：使用队列实现栈的功能。

解答：使用两个队列，一个用于入栈操作，一个用于出栈操作。

入栈操作：直接将元素入队入栈队列中；出栈操作：如果出栈队列为空，则将入栈队列的元素逐个出队并入队出栈队列，此时出栈队列的队首元素即为要出栈的元素。

栈和队列练习题答案

栈和队列(答案)1. 一个栈的入栈序列a,b,c,d,e,则栈的不可能的输出序列是__ C __。

A. edcbaB. decbaC. dceabD. abcde2. 若已知一个栈的入栈序列是1,2,3,…,n,其输出序列为p1,p2,p3,…,pn,若p1=n,则pi为__ C __。

A. iB. n=iC. n-i+1D. 不确定3. 栈结构通常采用的两种存储结构是__ A __。

A. 顺序存储结构和链式存储结构散列方式和索引方式链表存储结构和数组线性存储结构和非线性存储结构4. 判定一个顺序栈ST(最多元素为m0)为空的条件是_ B ___。

A. top !=0B. top= =0C. top !=m0D. top= =m0-15. 判定一个顺序栈ST(最多元素为m0)为栈满的条件是__ D __。

A. top!=0B. top= =0C. top!=m0D. top= =m0-16. PUSH 和POP 命令常用于(C)操作。

A 队列B 数组C 栈D 记录7. 向一个栈顶指针为HS的链栈中插入一个s所指结点时,则执行__ C __。

(不带空的头结点)A. HS—>next=s;B. s—>next= HS—>next; HS—>next=s;C. s—>next= HS; HS=s;D. s—>next= HS; HS= HS—>next;8. 从一个栈顶指针为HS的链栈中删除一个结点时,用x 保存被删结点的值,则执行_ B _ __。

(不带空的头结点)A. x=HS; HS= HS—>next;B. x=HS—>data;C. HS= HS—>next; x=HS—>data;D. x=HS—>data; HS= HS—>next;9. 一个队列的数据入队序列是1,2,3,4,则队列出队时的输出序列是__ B __ 。

二级MS Office高级应用(新大纲)选择题题目、解析及答案(栈、队列)

二级MS Office高级应用(新大纲)选择题题目、解析及答案（栈、队列）1.一个栈的初始状态为空。

现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（）。

A) 12345ABCDEB) EDCBA54321C) ABCDE12345D) 54321EDCBA参考答案：B解析：栈是只允许在表的一端进行插入和删除的线性表，如下图所示，允许插入的一端称为栈顶，它又称为“先进后出”或“后进先出”表。

例如：往弹夹中压子弹。

2.下列叙述中正确的是（）。

A）栈是"先进先出"的线性表B）队列是"先进后出"的线性表C）循环队列是非线性结构D）有序线性表既可以采用顺序存储结构，也可以采用链式存储结构参考答案：D解析：栈是“先进后出”或“后进先出”；队列是“先进先出”。

3.支持子程序调用的数据结构是（）。

A）栈B）树C）队列D）二叉树参考答案：A解析：主程序调用子程序时，使用栈先存储主程序，再存储子程序。

4.下列叙述中正确的是（）。

A) 循环队列有队头和队尾两个指针，因此，循环队列是非线性结构B) 在循环队列中，只需要队头指针就能反映队列中元素的动态变化情况C) 在循环队列中，只需要队尾指针就能反映队列中元素的动态变化情况D) 循环队列中元素的个数是由队头指针和队尾指针共同决定参考答案：D解析：循环队列是首尾相连的队列,如下图所示：元素个数=（front+n-rear）%n。

5.下列关于栈的叙述正确的是（）。

A) 栈按“先进先出”组织数据B) 栈按“先进后出”组织数据C) 只能在栈底插入数据D) 不能删除数据参考答案：B解析：栈是只允许在表的一端进行插入和删除的线性表，允许插入的一端称为栈顶，它以称为“先进后出”或“后进先出”表。

6.下列数据结构中，属于非线性结构的是（）。

A) 循环队列B) 带链队列C) 二叉树D) 带链栈参考答案：C解析：队列、栈是线性结构；树是非线性结构。

第二单元(栈和队列)(答案)

{
if(s->top<MAXSIZE)
{s->d[s->top]=x;
s->top++;
}
}
int pop(Seqstack *s)/*出栈操作*/
第二单元课后练习题
知识点范围：第3章栈和队列
一、选择题（每小题1分，共28分）
1．栈的特点是B，简称C的线性表；队列的特点是A，简称D的线性表。
A．先进先出B．后进先出
C．LIFOD．FIFO
2．栈和队列的共同点是C。
A．都是先进后出B．都是先进先出
C．只允许在端点处插入和删除元素D．没有共同点
10.一个栈的输入序列是12345，则栈的输出序列不可能是12345。(×)
11.若以链表作为栈的存储结构，则进栈需要判断栈是否满。(×)
12.循环队列中元素个数为rear-front。(×)
四、计算题(第1小题4分，第2小题3分，第3小题4分，共11分)
铁道进行车厢调度，如下图2.2所示a,b二条铁道均为单向行驶，设有1~6编号的6节车厢，若进站的车厢序列为123456，则求解如下问题。
(1)能否得到435612和135426的出站序列？
(2)写出三种不可能的出站序列。
(3)写出2种可能的出站序列及用S表示进栈、X表示出栈的栈操作序列。
图2.2
答：
(1)可以得到135426出站序列，栈操作序列如下：
入栈车厢号：123 45 6
栈操作：SXSSXSSXXXSX
出栈车厢号：1 3 5 4 2 6
20．若一个循环队列，其最多元素个数为MAXSIZE，front为头指针，rear为尾指针，则判定满队列的条件是A。
A．(rear+1)%MAXSIZE==frontB．rear+1==front

2013数据结构作业2-栈队列和数组-参考答案

作业2. 栈、队列、数组非编程作业：1．若进栈序列为ABCD ，请写出全部可能的出栈序列和不可能的出栈序列。

参考答案：可能的出栈序列：(14种)dcba cdba bacd cbda adcb cbad bdca acdb bcda acbd bcad abdc badc abcd不可能的出栈序列：(10种) d bca dbac dabc dacb dcab cabd cdab bdac cadb adbc2．简要说明循环队列如何判断队满和队空？参考答案：当牺牲一个存储结点，约定以“队列头指针在队列尾指针的下一位置（指环状的下一个位置）上” 作为队列“满”状态的标志时，循环队列判断队满的条件为：(Q.rear+1) % MaxQsize==Q.front ；判断队空的条件为：Q.front == Q.rear 。

3．设A 为n 阶对称矩阵，采用压缩存储存放于一维数组F[n(n+1)/2]中（从F[0]开始存放），请分别给出存放上三角阵时任一矩阵元素a ij （1≤i,j≤n ）的地址计算公式和存放下三角阵时任一矩阵元素a ij （1≤i,j ≤n ）的地址计算公式。

参考答案：存放上三角阵时，任一矩阵元素a ij （1≤i,j ≤n ）的地址计算公式为：()()ij 11+1Loc(a )=Loc(a )+1*2i i j l ⨯⎡⎤+-⎢⎥⎣⎦存放下三角阵时，任一矩阵元素a ij （1≤i,j ≤n ）的地址计算公式为：()()ij 11+1Loc(a )=Loc(a )+1*2j j i l ⨯⎡⎤+-⎢⎥⎣⎦4．写出下面稀疏矩阵的三元组顺序表和十字链表表示。

400000503008000000000700200000A ⎡⎤⎢⎥⎢⎥⎢⎥=⎢⎥⎢⎥⎢⎥⎣⎦参考答案：编程作业栈采用顺序栈存储，试设计算法实现将表达式转换成后缀表达式输出。

例如，输入表达式：a+b/c-(d*e+f)*g输出其后缀表达式：abc/+de*f+g*-参考答案：#include <stdio.h>#include <stdlib.h>#include <string.h>#define OVERFLOW -2#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int Status;typedef char SElemType;typedef char string[80];typedef struct{ SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack(SqStack &S){ S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) exit(OVERFLOW);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return(OK);}Status ClearStack(SqStack &S){ S.base=(SElemType*)realloc(S.base,STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) exit(OVERFLOW);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return(OK);}void DestroyStack(SqStack &S){ S.stacksize=0;if(S.base) free(S.base);S.base=S.top=NULL;}Status StackEmpty(SqStack S){ if(S.top==S.base)return true;elsereturn false;}SElemType GetTop(SqStack S){ SElemType e;if(S.top>S.base)e=*(S.top-1);return e;}Status 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(OVERFLOW);S.top=S.base+ S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S, SElemType &e){ if(S.top == S.base) //栈空return ERROR;e =*--S.top;return OK;}Status StackTraverse(SqStack S,void (*visit)(SElemType)) //栈遍历{ int i=0;if(!S.base) return ERROR;while(S.top>S.base)(*visit)(*S.base++);printf("\n");return OK;}Status InOP(SElemType c){char Operators[]={'+','-','*','/','(',')','#','\0'};int len=strlen(Operators);for(int i=0;i<len;i++)if(c==Operators[i])return true;return false;}SElemType Precede(SElemType curtop,SElemType input){ SElemType order;switch(input){case '+':case '-':switch(curtop){case '+':case '-':case '*':case '/':case ')': order='>'; break;case '(':case '#': order='<'; break;}break;case '*':case '/':switch(curtop){case '+':case '-':case '(':case '#': order='<'; break;case '*':case '/':case ')': order='>'; break;}break;case '(':switch(curtop){case '+': order='<'; break;case '-': order='<'; break;case '*': order='<'; break;case '/': order='<'; break;case '(': order='<'; break;case '#': order='<'; break;}break;case ')':switch(curtop){case '+': order='>'; break;case '-': order='>'; break;case '*': order='>'; break;case '/': order='>'; break;case '(': order='='; break;case ')': order='>'; break;}break;case '#':switch(curtop){case '+': order='>'; break;case '-': order='>'; break;case '*': order='>'; break;case '/': order='>'; break;case ')': order='>'; break;case '#': order='='; break;}break;}return order;}void Pass( string Suffix, SElemType ch) { *Suffix=ch;}void Transform(string Infix, string Suffix ){ SqStack S;SElemType ch,e;int flag=0,len;InitStack(S);Push(S, '#');len=strlen(Infix);*(Infix+len)='#';ch = *Infix;while (!StackEmpty(S)){ if (!InOP(ch))Pass( Suffix++, ch);else{ switch(Precede(GetTop(S),ch)){ case '<': Push(S,ch);flag=0;break;case '=': Pop(S,e);flag=0;break;case '>': Pop(S,e);Pass( Suffix++, e);flag=1;break;}}if(!flag)if (ch!='#')ch = *++Infix;}Pass(Suffix, '\0');DestroyStack(S);}void main(){ string Infix,Suffix;gets(Infix);Transform(Infix, Suffix) ;puts(Suffix);}。

数据结构作业二答案

作业二栈和队列一、填空题（每空1分，共15分）1. 栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶。

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

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

只能在队尾插入和队首删除元素。

3. 在具有n个单元的循环队列中，队满时共有n-1个元素。

4. 向栈中压入元素的操作是先移动栈顶指针，后存入元素。

5. 从循环队列中删除一个元素时，其操作是先移动队首指针，后取出元素。

二、判断正误（判断下列概念的正确性，并作出简要的说明。

）（每小题1分，共10分）（×）1. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。

错，线性表是逻辑结构概念，可以顺序存储或链式存储，与元素数据类型无关。

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

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

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

（×） 4. 栈和链表是两种不同的数据结构。

错，栈是逻辑结构的概念，是特殊殊线性表，而链表是存储结构概念，二者不是同类项。

（×） 5. 栈和队列是一种非线性数据结构。

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

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

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

（×）8. 队是一种插入与删除操作分别在表的两端进行的线性表，是一种先进后出型结构。

错，后半句不对。

（×）9. 一个栈的输入序列是12345，则栈的输出序列不可能是12345。

错，有可能。

三、单项选择题（每小题1分，共20分）（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。

栈和队列习题及答案

栈和队列习题及答案第三章栈和队列⼀、选择题1、⼀个栈的输⼊序列为：a，b，c，d，e，则栈的不可能输出的序列是（）。

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

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

A. 顺序表B. 链表C. 队列D. 栈4、带头结点的单链表head为空的判定条件是（）。

A. head==NULLB. head->next==NULLC. head->next!=NULLD. head!=NULL5、⼀个栈的输⼊序列为：1,2,3,4，则栈的不可能输出的序列是（）。

A. 1243B. 2134C. 1432D. 4312E. 32146、若⽤⼀个⼤⼩为6的数组来实现循环队列，且当rear和front的值分别为0，3。

当从队列中删除⼀个元素，再加⼊两个元素后，rear和front 的值分别为（）。

A. 1和5B. 2和4C. 4和2D. 5和17、队列的插⼊操作是在（）。

A. 队尾B. 队头C. 队列任意位置D. 队头元素后8、循环队列的队头和队尾指针分别为front和rear，则判断循环队列为空的条件是（）。

A. front==rearB. front==0C. rear==0D. front=rear+19、⼀个顺序栈S，其栈顶指针为top，则将元素e⼊栈的操作是（）。

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

数据结构习题及标准答案

数据结构习题及标准答案一、栈和队列1. 栈（Stack）是一种后进先出（Last-In-First-Out，LIFO）的数据结构。

栈的简单实现可以使用数组或链表，下面是一个使用数组实现的栈的示例代码：```pythonclass Stack:def __init__(self):self.stack = []def is_empty(self):return len(self.stack) == 0def push(self, item):self.stack.append(item)def pop(self):if self.is_empty():return Nonereturn self.stack.pop()def peek(self):if self.is_empty():return Nonereturn self.stack[-1]```2. 队列（Queue）是一种先进先出（First-In-First-Out，FIFO）的数据结构。

队列的简单实现也可以使用数组或链表，下面是一个使用链表实现的队列的示例代码：```pythonclass Queue:def __init__(self):self.queue = []def is_empty(self):return len(self.queue) == 0def enqueue(self, item):self.queue.append(item)def dequeue(self):if self.is_empty():return Nonereturn self.queue.pop(0)def peek(self):if self.is_empty():return Nonereturn self.queue[0]```二、链表1. 链表（Linked List）是一种常见的线性数据结构。

链表由节点组成，每个节点包含数据和指向下一个节点的指针。

栈和队列问答答案

数据结构复习题答案：栈和队列问答题1、解答：由栈的定义可知，这种结构的基本性质综述如下：(1)集合性。

栈是由若干个元素集合而成，当没有元素的空集合称为空栈；(2)线性结构。

除栈底元素和栈顶元素外，栈中任一元素均有唯一的前驱元素和后继元素；(3)受限制的运算。

只允许在栈顶实施压入或弹出操作，且栈顶位置由栈指针所指示；(4)数学性质。

当多个编号元素依某种顺序压入，且可任意时刻弹出时，所获得的编号元素排列的数目，恰好满足卡塔南数列的计算，即：Ｃn ＝Ｃn 2n /(n＋1)其中，n为编号元素的个数，Cn 是可能的排列数目。

2、解答：在队列的顺序存储结构中，设队头指针为front,队尾指针为rear,队的容量（存储空间的大小）为m。

当有元素要加入队列时，若rear＝m（初始时reat＝0），则发生队列的上溢现象，该元素不能加入队列。

这里要特别注意的是：队列的假溢出现象，队列中还有空余的空间，但元素不能进队列。

造成这种现象的原因是由于队列的操作方式所致。

解决队列的上溢有以下几种方法：(1)建立一个足够大的存储空间，但这样做往往会造成空间使用的效率低。

(2)当出现假溢出时，可采用以下几种方法：①采用平移元素的方法。

每当队列中加入一个元素时，队列中已有的元素向队头移动一个位置（当然要有空余的空间可移）；②每当删去一个队头元素时，则依次序移队中的元素，始终使front指针指向队列中的第一个位置；③采用循环队列方式。

把队头队尾看成是一个首尾相邻的循环队列，虽然物理上队3、解答：(1) 解答:status insert(Rear,x){// 假定Rear为循环链队的队尾指针，x为待插入的元素(1) malloc(p);p->data＝x; // 建立值为x的新结点p＾(2) if( Rear＝nil){Rear＝p; Rear->next＝p;}else {p->next＝Rear->next;Rear->next＝p; Rear＝p;}// 若条件成立则建立循环链队的第一个结点，否则在队尾插入p＾结点}(2) 解答:status delete(Rear){if( Rear＝nil ) error('underflow');if (Rear->next= =Rear) Rear＝nil;else Rear->next＝Rear->next->next;} //Rear＾.next 所指向的结点为循环链队的队首结点4、栈是允许在同一端进行插入和删除操作的特殊线性表。

栈和队列课后习题答案

第三章栈和队列课后习题答案1、单项选择题（1） B（2） B（3） D（4） D（5） C（6） C（7） B（8） C（9） B（10）C2、填空题（1）后进先出先进先出（2）front = rear （rear+1）% Max = front（3）top = 0 top =N-1（4）空空只含有一个结点（5）p->next=top; top=p;（6）rear->next=p; rear=p;（7） 4（8）假上溢3、问答题（1）参考答案：栈的操作特点是后进先出，因此输出序列有：A入，A出，B入，B出，C入C出，输出序列为ABC。

A入，A出，B入，C入，C出，B出，输出序列为ACB。

A入，B入，B出，A出，C入，C出，输出序列为BAC。

A入，B入，B出，C入，C出，A出，输出序列为BCA。

A入，B入，C入，C出，B出，A出，输出序列为CBA。

（2）参考答案：8 3 5 + 5 6 2 / - * -（3）参考答案：一个过程（或函数）直接或间接调用自己，这种过程（或函数）叫递归过程（或函数）。

递归算法一般用于解决三类问题：1）数据的定义是按递归定义的。

（Fibonacci函数）2）问题解法按递归算法实现。

（回溯）3）数据的结构形式是按递归定义的。

（树的遍历，图的搜索）设计递归算法的方法：①寻找递归通式，分解问题；②设置递归出口，确定递归终止条件。

（4）参考答案：向一个顺序栈插入一个元素时，首先使栈顶指针后移一个位置，然后把待插入元素写入到这个位置上。

（5）参考答案：向一个链栈插入一个新结点时，首先把栈顶指针的值赋给新结点的指针域，然后把新结点的存储位置赋给栈顶指针。

（6）参考答案：①一种是在定义结构体时，附设一个存储循环队列中元素个数的变量如n，当n=0时，队空。

当n=MaxSize时为队满。

②另一种方法是少用一个元素控件，约定当尾指针加1等于头指针时，认为是队满，可用于求模运算来实现，即front=rear，称为队空。

数据结构练习题第三章栈、队列和数组习题及答案

进行插入运算，被称为或，在栈顶进行删除运算，被称为
或。
2.栈的基本运算至少应包括、、、、五
种。
3.对于顺序栈，若栈顶下标值top=0,此时，如果作退栈运算，则产生“”。
4.对于顺序栈而言，在栈满状态下，如果此时在作进栈运算，则会发生“”。
5.一般地，栈和线性表类似有两种实现方法，即实现和实现。
6.top=0表示，此时作退栈运算，则产生“”；top=sqstack_maxsize-1
中无元素，此时。
26．以下运算实现在链队上的初始化，请在void InitQueue(QueptrTp *lp)
{LqueueTp *p;
p=(LqueueTp *)malloc(sizeof(LqueueTp))
；
lq->rear=p;
(lq->front)->next=;
}
27.以下运算实现在链队上的入队列，请在
处用适当句子予以填充。
的情况。当lq.front==lq.rear试，队
处用适当句子予以填充。
处用适当句子予以填充。
28.以下运算实现在链队上的出队列，请在处用适当句子予以填充。
int OutQueue(QuetrTp *lq,DataType *x)
{ LqueueTp *s;
if(lq->front==lq->rear){erroe(“队空”)；return(0);}
return(1);}
}
12.以下运算实现在链栈上的初始化，请在处用请适当句子予以填充。
Void InitStacl(LstackTp *ls){;}
13.'以下运算实现在链栈上的进栈，请在处用请适当句子予以填充。

栈和队列答案

3.1 若按教科书 3.1.1 节中图 3.1(b) 所示铁道进行车厢调度（注意：两侧铁道均为单向行驶道），则请回答：(1) 如果进站的车厢序列为123，则可能得到的出站车厢序列是什么？(2)如果进站的车厢序列为 123456，则能否得到 435612 和 135426 的出站序列，并请说明为什么不能得到或者如何得到（即写出以‘S’表示进栈和以‘ X’表示出栈的栈操作序列）。

解： (1) 123 231 321 213 132(2) 可以得到明12 已经在栈中，135426 的出站序列，但不能得到1 不可能先于2 出栈。

435612的出站序列。

因为4356 出站说3.2简述栈和线性表的差别。

解：线性表是具有相同特性的数据元素的一个有限序列。

栈是限定仅在表尾进行插入或删除操作的线性表。

3.3写出下列程序段的输出结果（栈的元素类型SElemType 为 char ）。

void main(){Stack S;char x,y;InitStack(S);x= ‘ c’ ; y=‘ k’ ;Push(S,x);Push(S,‘ a’ ); Push(S,y);Pop(S,x);Push(S,‘ t’ ); Push(S,x);Pop(S,x);Push(S,‘ s’ );while(!StackEmpty(S)) { Pop(S,y); printf(y); }printf(x);}解： stack3.4简述以下算法的功能（栈的元素类型SElemType为int）。

(1)status algo1(Stack S){int i,n,A[255];n=0;while(!StackEmpty(S)) { n++; Pop(S,A[n]); }for(i=1;i<=n;i++) Push(S,A[i]);}(2)status algo2(Stack S,int e){Stack T; int d;InitStack(T);while(!StackEmpty(S)){Pop(S,d);if(d!=e) Push(T,d);}while(!StackEmpty(T)){Pop(T,d);Push(S,d);}}解： (1)栈中的数据元素逆置(2)如果栈中存在元素e，将其从栈中清除3.5假设以S和X分别表示入栈和出栈的操作，则初态和终态均为空栈的入栈和出栈的操作序列可以表示为仅由S 和 X 组成的序列。

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

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

一、选择题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 ）。