数据结构第三章.docx
《数据结构第三章.docx》由会员分享，可在线阅读，更多相关《数据结构第三章.docx（10页珍藏版）》请在冰豆网上搜索。
数据结构第三章
二、简述栈和线性表的区别。
答：
线性结构的特点是在数据元素的非空有限集中，存在惟一的一个被称为“第一个”的数据元素；存在惟一的一个被称做“最后一个”的数据元素；除第一个之外，集合中的每个数据元素均只有一个前驱；；除最后一个之外，集合中每个数据元素均只有一个后继。
线性表是最常用且最简单的一种数据结构。
一个线性表是n个数据元素的有限序列。
线性表是一个相当灵活的数据结构，它的长度可根据需要增长或缩短，即对线性表的数据元素不仅可以访问，还可在在任意位置进行插入和删除操作等。
栈是一种特殊的线性结构，从数据的逻辑结构角度来看，栈是线性表，从操作的角度来看，栈的基本操作是线性表操作的子集，是操作受限制的线性表，其特点是栈限定仅在表尾进行插入和删除操作的线性表，它的存取特征是后进先出。
三、写出下列程序段的输出结果（栈的元素类型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）;
}
输出结果：
stack
四、简述以下算法的功能（栈的元素类型SelemType为int）。
1、statusalgol（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）;
}
}
答案：
利用栈T辅助将栈S中所有值为e的数据元素删除。
二十八、．假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的置空队、判队空、入队和出队等算法。
【分析】带头结点的循环链表表示的队列如图3-7所示，仅有队尾指针rear，但可通过rear->next找到头结点，再通过头结点找到队头，即rear->next->next。
图3-7带头结点的循环链表队列
【算法】
①置空队
LinkListSetNull（）{
LinkListrear;
rear=newLNode;
rear->next=rear;
returnrear;
}
②判队空
intEmpty（LinkListrear）{
if（rear->next==rear）
return1;//若队列为空返回1
else
return0;//否则返回0
}
③入队
LinkListENQUEUE（LinkListrear,DataTypex）{
LinkListp;
p=newLinkList;
p->data=x;
p->next=rear->next;//将p插入到rear->next之后
rear->next=p;
rear=p;
returnrear;//返回新的队尾指针
}
④出队
LinkListDEQUEUE（LinkListraer,DataType*x）{
LNode*p,*q;
if（rear->next==rear）//若队空，则输出队空信息
cout<<“EMPTY”;
else{
q=rear->next;
p=q->next;
}//否则q指向头结点，p指向队头
if（p==rear）
rear=q;//若队中仅有一个元素，则将rear指向头结点
q->next=p->next;//将p所指结点出队
*x=p->data;
deletep;//将对头结点的值赋给形参*x
returnrear;//返回队尾指针
}
二十九、如果希望循环队列中的元素都能得到利用，则需设置一个标志域tag，并以tag的值为0或1来区分，尾指针和头指针值相同时的队列状态是“空”还是“满”。
试编写与此结构相应的入队列和出队列的算法。
解：
StatusEnCyQueue（CyQueue&Q,intx）//带tag域的循环队列入队算法
{
if（Q.front==Q.rear&&Q.tag==1）//tag域的值为0表示"空",1表示"满"
returnOVERFLOW;
Q.base[Q.rear]=x;
Q.rear=（Q.rear+1）%MAXSIZE;
if（Q.front==Q.rear）Q.tag=1;//队列满
}//EnCyQueue
StatusDeCyQueue（CyQueue&Q,int&x）//带tag域的循环队列出队算法
{
if（Q.front==Q.rear&&Q.tag==0）returnINFEASIBLE;
Q.front=（Q.front+1）%MAXSIZE;
x=Q.base[Q.front];
if（Q.front==Q.rear）Q.tag=1;//队列空
returnOK;
}//DeCyQueue
三十、假设循环队列中只设rear和length来分别指示队尾元素的位置和队中元素的个数，试给出判别此循环队列的队满条件，并写出相应的入队和出队算法，要求出队时需返回队头元素。
解：
根据题意，可定义该循环队列的存储结构：
#defineQueueSize100
typedefcharDatatype;//设元素的类型为char型
typedefstruct{
intlength;
intrear;
DatatypeData[QueueSize];
}CirQueue;
CirQueue*Q;
循环队列的队满条件是：
Q->length==QueueSize
知道了尾指针和元素个数，当然就能计算出队头元素的位置。
算法如下：
（1）判断队满
intFullQueue（CirQueue*Q）
{//判队满,队中元素个数等于空间大小
returnQ->length==QueueSize;
}
（2）入队
voidEnQueue（CirQueue*Q,Datatypex）
{//入队
if（FullQueue（Q））
Error（"队已满，无法入队"）;
Q->Data[Q->rear]=x;
Q->rear=（Q->rear+1）%QueueSize;//在循环意义上的加1
Q->
length++;
}
（3）出队
DatatypeDeQueue（CirQueue*Q）
{//出队
if（Q->length==0）
Error（"队已空，无元素可出队"）;
inttmpfront;//设一个临时队头指针
tmpfront=（QueueSize+Q->rear-Q->quelen+1）%QueueSize;//计算头指针位置
Q->length--;
returnQ->Data[tmpfront];
}
三十一、回文是指正读和反读均相同的字符序列，如“abba”和“abdba”均是回文，但“good”不是回文。
试写一个算法判定给定的字符向量是否为回文。
解：
#include"stdio.h"
#definestacksize100
typedefchardatatype;
typedefstruct
{datatypedata[stacksize];
inttop;
}seqstack;
stacknull（seqstack*p）
{p->top=-1;}
Intstackfull（seqstack*p）
{
returnp->top==stacksize-1;
}
tackempty（seqstack*p）
{
if（p->top==-1）return1;
elsereturn0;
}
push（seqstack*p,datatypex）
{
if（stackfull（p））
{printf（"itiswrong."）;exit（0）;}
p->top++;
p->data[p->top]=x;
}
pop（seqstack*p）
{
if（stackempty（p））
{printf（"error"）;exit（0）;}
return（p->data[p->top--]）;
}
main（）
{
chartemp;
intn,i,length=0;
seqstackl;
stacknull（&l）;
clrscr（）;
printf（"thetopis%d",l.top）;
printf（"\ninputchar:
"）;
printf（"\ninputn:
"）;
scanf（"%d\n",&n）;
for（i=0;i{
scanf（"%c",&l.data[i]）;
length++;
}
printf（"\n"）;
length=length-1;
printf（"\nthelengthis%d",length）;
for（i=0;i<（length/2）;i++）
{
push（&l,l.data[i]）;
}
if（length%2==0）
{
for（i;iif（temp=pop（&l）!
=l.data[i]）
{printf（"\nitiserror."）;exit（0）;}
printf（"\nitistrue."）;
}
else
{
for（i;iif（temp=pop（&l）!
=l.data[i+1]）
{printf（"\nitiserror."）;exit（0）;}
printf（"\nitistrue."）;
}
补充题：
一、设将整数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
二、链栈中为何不设置头结点?
答：
链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要对头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。
三、循环队列的优点是什么?
如何判别它的空和满?
答：
循环队列的优点是：
它可以克服顺序队列的"假上溢"现象，能够使存储队列的向量空间得到充分的利用。
判别循环队列的"空"或"满"不能以头尾指针是否相等来确定，一般是通过以下几种方法：
一是另设一布尔变量来区别队列的空和满。
二是少用一个元素的空间,每次入队前测试入队后头尾指针是否会重合，如果会重合就认为队列已满。
三是设置一计数器记录队列中元素总数，不仅可判别空或满，还可以得到队列中元素的个数。
四、设长度为n的链队用单循环链表表示，若设头指针，则入队出队操作的时间为何?
若只设尾指针呢?
答：
当只设头指针时，出队的时间为1，而入队的时间需要n，因为每次入队均需从头指针开始查找，找到最后一个元素时方可进行入队操作。
若只设尾指针，则出入队时间均为1。
因为是循环链表，尾指针所指的下一个元素就是头指针所指元素，所以出队时不需要遍历整个队列。
五、指出下述程序段的功能是什么?
（1）voidDemo1（SeqStack*S）{
inti;arr[64];n=0;
while（StackEmpty（S））arr[n++]=Pop（S）;
for（i=0,i }//Demo1
（2）SeqStackS1,S2,tmp;
DataTypex;
...//假设栈tmp和S2已做过初始化
while（!
StackEmpty（&S1））
{
x=Pop（&S1）;
Push（&tmp,x）;
}
while（!
StackEmpty（&tmp））
{
x=Pop（&tmp）;
Push（&S1,x）;
Push（&S2,x）;
}
（3）voidDemo2（SeqStack*S,intm）
{//设DataType为int型
SeqStackT;inti;
InitStack（&T）;
while（!
StackEmpty（S））
if（（i=Pop（S））!
=m）Push（&T,i）;
while（!
StackEmpty（&T））
{
i=Pop（&T）;Push（S,i）;
}
}
（4）voidDemo3（CirQueue*Q）
{//设DataType为int型
intx;SeqStackS;
InitStack（&S）;
while（!
QueueEmpty（Q））
{x=DeQueue（Q）;Push（&S,x）;}
while（!
StackEmpty（&s））
{x=Pop（&S）;EnQueue（Q,x）;}
}//Demo3
（5）CirQueueQ1,Q2;//设DataType为int型
intx,i,n=0;
...//设Q1已有内容，Q2已初始化过
while（!
QueueEmpty（&Q1））
{x=DeQueue（&Q1）;EnQueue（&Q2,x）;n++;}
for（i=0;i {x=DeQueue（&Q2）;
EnQueue（&Q1,x）;EnQueue（&Q2,x）;}
答：
（1）程序段的功能是将一栈中的元素按反序重新排列，也就是原来在栈顶的元素放到栈底，栈底的元素放到栈顶。
此栈中元素个数限制在64个以内。
（2）程序段的功能是利用tmp栈将一个非空栈s1的所有元素按原样复制到一个栈s2当中去。
（3）程序段的功能是利用栈T，将一个非空栈S中值等于m的元素全部删去。
（4）程序段的功能是将一个循环队列Q经过S栈的处理，反向排列，原来的队头变成队尾，原来的队尾变成队头。
（5）这段程序的功能是将队列1的所有元素复制到队列2中去，但其执行过程是先把队列1的元素全部出队，进入队列2，然后再把队列2的元素复制到队列1中。
.
升级会员 