完整版《数据结构》习题集第3章栈和队列.docx
《完整版《数据结构》习题集第3章栈和队列.docx》由会员分享，可在线阅读，更多相关《完整版《数据结构》习题集第3章栈和队列.docx（21页珍藏版）》请在冰豆网上搜索。
完整版《数据结构》习题集第3章栈和队列
第3章栈和队列
一、选择题
1.栈结构通常采用的两种存储结构是（A）。
A、顺序存储结构和链表存储结构B、散列和索引方式
C、链表存储结构和数组D、线性链表结构和非线性存储结构
2.设栈ST用顺序存储结构表示，则栈ST为空的条件是（B）
A、ST.top-ST.base<>0B、ST.top-ST.base==0
C、ST.top-ST.base<>nD、ST.top-ST.base==n
3.向一个栈顶指针为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;
4.从一个栈顶指针为HS的链栈中删除一个结点，用x保存被删除结点的值，则执行（C）
A、x=HS；HS=HS->next;B、HS=HS->next；x=HS->data;
C、x=HS->data；HS=HS->next;D、s->next=Hs；Hs=HS->next;
5.表达式a*（b+c）-d的后缀表达式为（B）
A、abcdd+-B、abc+*d-C、abc*+d-D、-+*abcd
6.中缀表达式A-（B+C/D）*E的后缀形式是（D）
A、AB-C+D/E*B、ABC+D/E*C、ABCD/E*+-D、ABCD/+E*-
7.一个队列的入列序列是1，2，3，4，则队列的输出序列是（B）
A、4，3，2，1B、1，2，3，4C、1，4，3，2D、3，2，4，1
8.循环队列SQ采用数组空间SQ.base[0,n-1]存放其元素值，已知其头尾指针分别是front和rear，则判定此循环队列为空的条件是（）
A、Q.rear-Q.front==nB、Q.rear-Q.front-1==n
C、Q.front==Q.rearD、Q.front==Q.rear+1
9.循环队列SQ采用数组空间SQ.base[0,n-1]存放其元素值，已知其头尾指针分别是front和rear，则判定此循环队列为满的条件是（）
A、Q.front==Q.rearB、Q.front!
=Q.rear
C、Q.front==（Q.rear+1）%nD、Q.front!
=（Q.rear+1）%n
10.若在一个大小为6的数组上实现循环队列，且当前rear和front的值分别为0和3，当从队列中删除一个元素，再加入两个元素后，rear和front的值分别为（）
A、1，5B、2,4C、4，2D、5，1
11.用单链表表示的链式队列的队头在链表的（）位置
A、链头B、链尾C、链中
12.判定一个链队列Q（最多元素为n个）为空的条件是（）
A、Q.front==Q.rearB、Q.front!
=Q.rear
C、Q.front==（Q.rear+1）%nD、Q.front!
=（Q.rear+1）%n
13.在链队列Q中，插入s所指结点需顺序执行的指令是（）
A、Q.front->next=s；f=s;B、Q.rear->next=s；Q.rear=s;
C、s->next=Q.rear；Q.rear=s;D、s->next=Q.front；Q.front=s;
14.在一个链队列Q中，删除一个结点需要执行的指令是（）
A、Q.rear=Q.front->next;B、Q.rear->next=Q.rear->next->next;
C、Q.front->next=Q.front->next->next;D、Q.front=Q.rear->next;
15.用不带头结点的单链表存储队列，其队头指针指向队头结点，队尾指针指向队尾结点，则在进行出队操作时（）
A、仅修改队头指针B、仅修改队尾指针
C、队头尾指针都要修改D、队头尾指针都可能要修改。
16.栈和队列的共同点是（）
A、都是先进后出B、都是先进先出
C、只允许在端点处插入和删除元素D、没有共同点
17.消除递归（）需要使用栈。
A、一定B、不一定
18.设有一顺序栈S，元素s1，s2，s3，s4，s5，s6依次进栈，如果6个元素出栈的顺序是s2，s3，s4，s6，s5，s1，则栈的容量至少应该是（）
A、2B、3C、5D、6
19.若一个栈的输入序列是a，b，c，则通过入、出栈操作可能得到a,b,c的不同排列个数为（）
A、4B、5C、6D、7
20.设有一顺序栈已经含有3个元素，如图3.1所示元素a4正等待进栈。
下列不可能出现的出栈序列是（）
A、a3,a1,a4,a2B、a3,a2,a4,a1C、a3,a4,a2,a1D、a4,a3,a2,a1
图3.1
21.链栈和顺序栈相比，有一个比较明显的优势是（）
A、通常不会出现栈满的情况B、通常不会出现栈空的情况
C、插入操作更容易实现D、删除操作更加容易实现
22.若一个栈的输入序列是1，2，3，4，…，n，输出序列的第一个元素是n，则第i个输出元素是（C）
A、不确定B、n-iC、n-i+1D、n-i-1
23.以下说法正确的是（）
A、因链栈本身没有容量限制,故在用户内存空间的范围内不会出现栈满情况
B、因顺序栈本身没有容量限制,故在用户内存空间的范围内不会出现栈满情况
C、对于链栈而言,在栈满状态下,如果此时再作进栈运算，则会发生“上溢”
D、对于顺序栈而言在栈满状态下如果此时再作进栈运算，则会发生“下溢”。
二、判断题
1.在顺序栈栈满情况下，不能做进栈运算，否则会产生“上溢”。
2.链栈与顺序栈相比的一个优点是链栈插入和删除操作更加方便。
3.若一个栈的输入序列为1，2，3，…，n，其输出序列的第一个元素为n，则其输出序列的每个元素一定满足ai=i+1（i=1,2,…,n）。
4.在链队列中，即使不设置尾指针也能进行入队操作。
5.在对链队列（带头指针）做出队操作时，不会改变front指针的值。
6.循环队列中元素个数为rear-front。
7.一个栈的输入序列是1,2,3,4，则在栈的输出序列中可以得到4,3,1,2。
8.一个栈的输入序列是1,2,3,4，则在栈的输出序列中可以得到1,2,3,4。
9.若以链表作为栈的存储结构，则进栈需要判断栈是否满。
10.若以链表作为栈的存储结构，则出栈需要判断栈是否空。
三、填空题
1.栈的特点是（先进后出），队列的特点是（先进先出）。
2.线性表、栈、队列都是（）结构，可以在线性表的（）位置插入和删除元素；对于栈只能在（）插入和删除元素；对于队列只能在（）插入元素和在（）位置删除元素。
3.有程序如下，则此程序的输出结果（栈的元素类型是SelemType为char）是（）。
voidmain（）{
stacks;
charx,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）;
}
4.在栈顶指针为HS的链栈中，判定栈空的条件是（）。
5.向栈中压入元素的操作是先（）后（）。
6.对栈进行退栈操作是先（）后（）。
7.用循环链表表示的队列长度为n，若只设头指针，则出队和入队的时间复杂度分别是（）和（）；若只设尾指针，则出队和入队的时间复杂度分别是（）和（）。
8.从循环队列中删除一个元素时，其操作是（）。
9.在一个循环队列中，队首指针指向队首元素的（）。
10.在具有n个单元的循环队列中，队满时共有（）个元素。
11.在HQ的链队列中，判断只有一个结点的条件是（）。
12.设栈S和队列Q的初始状态为空，元素a、b、c、d、e、f依次通过栈S，一个元素出栈后即进入队列Q。
若这6个元素出队列的顺序是b、d、c、f、e、a则栈S的容量至少应该是（）。
13.有程序如下，则此程序的输出结果（队列的元素类型是QSelemType为char）是（）。
voidmain（）{
charx=’e’,y=’c’;
enqueue（q,’h’）;enqueue（q,’r’）;enqueue（q,y）;dequeue（q,x）;enqueue（q,x）;degueue（q,x）;
enqueue（q,’a’）;
while（!
queueempty（q））{
dequeue（q,y）;printf（y）;
}
printf（x）;
}
14.有如下递归函数：
intdunno（intm）{
intvalue;
if（m==0）
value=3;
else
value=dunno（m-1）+5;
return（value）;
}
执行语句printf（“%d\n”,dunno（3））;的结果是（）。
四、简答题
1.对于堆栈，给出三个输入项A，B，C，如果输入项序列为ABC，试给出全部可能的输出序列，并写
出每种序列对应的操作。
例如：
A进B进C进C出B出A出，产生的序列为CBA。
2.简述以下算法的功能（栈的元素类型是SelemType为int）。
（1）
statusalgo1（stacks）{
intI,n,a[255];
n=0;
while（!
stackempty（s））{
n++;
pop（s,a[n]）;
}
for（I=1;I<=n;I++）
push（s,a[I]）;
}
（2）
statusalgo2（stacks,inte）{
stackt;intd;
initstack（t）;
while（!
stackempty（s））{
pop（s,d）;
if（d!
=e）
push（t,d）;
}
while（!
stackempty（t））{
pop（t,d）;
push（s,d）;
}
}
3.内存中一片连续空间（不妨假设地址从0到m-1）提供给两个栈s1和s2使用，怎样分配这部分存储空间，使得对任一栈仅当这部分空间全满时才发生溢出。
4.有递归过程如下：
voidprint（intw）{
intI;
if（w!
=0）{
print（w-1）;
for（I=1;I<=w;I++）
printf（“%3d”,w）;
printf（“\n”）;
}
}
问：
调用语句print（4）的结果是什么？
5.简述以下算法的功能（栈和队列的元素类型均为int）
voidalgo（queue&q）{
stacks;
intd;
initstack（s）;
while（!
queueempty（q））{
dequeue（q,d）;
push（s,d）;
}
while（!
stackempty（s））{
pop（s,d）;
enqueue（q,d）;
}
}
6.假设Q[0，9]是一个非循环线性队列，初始状态为front=rear=0，画出做完下列操作后队列的头尾指针的状态变化情况，如果不能入队，请指出其元素，并说明理由。
d,e,b,g,h入队d,e出队I,j,k,l,m入队b出队n,o,p,q,r入队。
7.按照运算符优先数法，画出对下面算术表达式求值时，操作数栈和运算符栈的变化过程：
9-2*4+（8+1）/3。
8.设栈S＝（1，2，3，4，5，6，7），其中7为栈顶元素。
写出调用algo后栈S的状态。
voidalgo（Stack*S）{
inti=0;
QueueQ;
StackT;
InitQueue（Q）;
InitStack（T）;
while（!
StackEmpty（S））{
if（i%2==0）
Push（T,Pop（S））;
else
EnQueue（Q,Pop（S））;
i++;
}
while（!
QueueEmpty（Q））
Push（S,DeQueue（Q））;
while（!
StackEmpty（T））
Push（S,Pop（T））;
}
五、设计题
1.回文是指正读反读均相同的字符序列，如“abba”和“abdba”均是回文，但“good”不是回文。
试写一个算法判定给定的字符向量是否为回文。
（提示：
将一半字符入栈）
2.设从键盘输入一整数的序列：
a1,a2,a3，…，an，试编写算法实现：
用栈结构存储输入的整数，当ai≠-1时，将ai进栈；当ai=-1时，输出栈顶整数并出栈。
算法应对异常情况（入栈满等）给出相应的信息。
3.从键盘上输入一个后缀表达式，试编写算法计算表达式的值。
规定：
逆波兰表达式的长度不超过一行，以$符作为输入结束，操作数之间用空格分隔,操作符只可能有+、-、*、/四种运算。
例如：
23434+2*$。
4.假设以I和O分别表示入栈和出栈操作。
栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，称可以操作的序列为合法序列，否则称为非法序列。
下面所示的序列中哪些是合法的？
A.IOIIOIOOB.IOOIOIIOC.IIIOIOIOD.IIIOOIOO
通过对
的分析，写出一个算法，判定所给的操作序列是否合法。
若合法，返回true，否则返回false（假定被判定的操作序列已存入一维数组中）。
5.假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素站点（注意不设头指针），试编写相应的置空队、判队空、入队和出队等算法。
6.假设以数组Q[m]存放循环队列中的元素,同时设置一个标志tag，以tag==0和tag==1来区别在队头指针（front）和队尾指针（rear）相等时，队列状态为“空”还是“满”。
试编写与此结构相应的插入（enqueue）和删除（dlqueue）算法。
7.如果允许在循环队列的两端都可以进行插入和删除操作。
要求：
写出循环队列的类型定义；
写出“从队尾删除”和“从队头插入”的算法。
8.已知Ackermann函数定义如下:
a）
写出计算Ack（m,n）的递归算法，并根据此算法给出出Ack（2,1）的计算过程。
写出计算Ack（m,n）的非递归算法。
9.已知f为单链表的表头指针,链表中存储的都是整型数据，试写出实现下列运算的递归算法：
求链表中的最大整数；
求链表的结点个数；
求所有整数的平均值。
（2）回文是指正读反读均相同的字符序列，如“abba”和“abdba”均是回文，但“good”不是回文。
试写一个算法判定给定的字符向量是否为回文。
（提示：
将一半字符入栈）
根据提示，算法可设计为：
//以下为顺序栈的存储结构定义
#defineStackSize100//假定预分配的栈空间最多为100个元素
typedefcharDataType;//假定栈元素的数据类型为字符
typedefstruct{
DataTypedata[StackSize];
inttop;
}SeqStack;
intIsHuiwen（char*t）
{//判断t字符向量是否为回文，若是，返回1，否则返回0
SeqStacks;
inti,len;
chartemp;
InitStack（&s）;
len=strlen（t）;//求向量长度
for（i=0;i Push（&s,t[i]）;
while（!
EmptyStack（&s））
{//每弹出一个字符与相应字符比较
temp=Pop（&s）;
if（temp!
=S[i]） return0;//不等则返回0
elsei++;
}
return1;//比较完毕均相等则返回1
}
（3）设从键盘输入一整数的序列：
a1,a2,a3，…，an，试编写算法实现：
用栈结构存储输入的整数，当ai≠-1时，将ai进栈；当ai=-1时，输出栈顶整数并出栈。
算法应对异常情况（入栈满等）给出相应的信息。
#definemaxsize栈空间容量
voidInOutS（ints[maxsize]）
//s是元素为整数的栈，本算法进行入栈和退栈操作。
{inttop=0;//top为栈顶指针，定义top=0时为栈空。
for（i=1;i<=n;i++）//n个整数序列作处理。
{scanf（“%d”,&x）;//从键盘读入整数序列。
if（x!
=-1）//读入的整数不等于-1时入栈。
if（top==maxsize-1）{printf（“栈满\n”）;exit（0）;}elses[++top]=x;//x入栈。
else//读入的整数等于-1时退栈。
{if（top==0）{printf（“栈空\n”）;exit（0）;}elseprintf（“出栈元素是%d\n”,s[top--]）；}}
}//算法结束。
（4）从键盘上输入一个后缀表达式，试编写算法计算表达式的值。
规定：
逆波兰表达式的长度不超过一行，以$符作为输入结束，操作数之间用空格分隔,操作符只可能有+、-、*、/四种运算。
例如：
23434+2*$。
[题目分析]逆波兰表达式（即后缀表达式）求值规则如下：
设立运算数栈OPND,对表达式从左到右扫描（读入），当表达式中扫描到数时，压入OPND栈。
当扫描到运算符时，从OPND退出两个数，进行相应运算，结果再压入OPND栈。
这个过程一直进行到读出表达式结束符$，这时OPND栈中只有一个数，就是结果。
floatexpr（）
//从键盘输入逆波兰表达式，以‘$’表示输入结束，本算法求逆波兰式表达式的值。
｛floatOPND[30];//OPND是操作数栈。
init（OPND）;//两栈初始化。
floatnum=0.0;//数字初始化。
scanf（“%c”,&x）;//x是字符型变量。
while（x!
=’$’）
{switch
{case‘0’<=x<=’9’:
while（（x>=’0’&&x<=’9’）||x==’.’）//拼数
if（x!
=’.’）//处理整数
{num=num*10+（ord（x）-ord（‘0’））;scanf（“%c”,&x）;}
else//处理小数部分。
{scale=10.0;scanf（“%c”,&x）;
while（x>=’0’&&x<=’9’）
{num=num+（ord（x）-ord（‘0’）/scale;
scale=scale*10;scanf（“%c”,&x）;}
}//else
push（OPND,num）;num=0.0;//数压入栈，下个数初始化
casex=‘’:
break;//遇空格，继续读下一个字符。
casex=‘+’:
push（OPND,pop（OPND）+pop（OPND））;break;
casex=‘-’:
x1=pop（OPND）;x2=pop（OPND）;push（OPND,x2-x1）;break;
casex=‘*’:
push（OPND,pop（OPND）*pop（OPND））;break;
casex=‘/’:
x1=pop（OPND）;x2=pop（OPND）;push（OPND,x2/x1）;break;
default:
//其它符号不作处理。
}//结束switch
scanf（“%c”,&x）;//读入表达式中下一个字符。
}//结束while（x！
=‘$’）
printf（“后缀表达式的值为%f”,pop（OPND））;
}//算法结束。
[算法讨论]假设输入的后缀表达式是正确的，未作错误检查。
算法中拼数部分是核心。
若遇到大于等于‘0’且小于等于‘9’的字符，认为是数。
这种字符的序号减去字符‘0’的序号得出数。
对于整数，每读入一个数字字符，前面得到的部分数要乘上10再加新读入的数得到新的部分数。
当读到小数点，认为数的整数部分已完，要接着处理小数部分。
小数部分的数要除以10（或10的幂数）变成十分位，百分位，千分位数等等，与前面部分数相加。
在拼数过程中，若遇非数字字符，表示数已拼完，将数压入栈中，并且将变量num恢复为0，准备下一个数。
这时对新读入的字符进入‘+’、‘-’、‘*’、‘/’及空格的判断，因此在结束处理数字字符的case后，不能加入break语句。
（5）假设以I和O分别表示入栈和出栈操作。
栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，称可以操作的序列为合法序列，否则称为非法序列。
下面所示的序列中哪些是合法的？
A.IOIIOIOOB.IOOIOIIOC.IIIOIOIOD.IIIOOIOO
通过对
的分析，写出一个算法，判定所给的操作序列是否合法。
若合法，返回true，否则返回false（假定被判定的操作序列已存入一维数组中）。
A和D是合法序列，B和C是非法序列。
设被判定的操作序列已存入一维数组A中。
intJudge（charA[]）
//判断字符数组A中的输入输出序列是否是合法序列。
如是，返回true，否则返回false。
{i=0;//i为下标。
j=k=0;//j和k分别为I和字母O的的个数。
while（A[i]!
=‘\0’）//当未到字符数组尾就作。
{switch（A[i]）
{case‘I’:
j++;break;//入栈次数增1。
case‘O’:
k++;if（k>j）{printf（“序列非法\n”）；exit（0）;}
}
i++;//不论A[i]是‘I’或‘O’，指针i均后移。
}
if（j!
=k）{printf（“序列非法\n”）；return（false）;}
else{printf（“序列合法\n”）；return（true）;}
}//算法结束。
[算法讨论]在入栈出栈序列（即由‘I’和‘O’组成的字符串）的
升级会员 