第三章 栈与队列.docx
《第三章 栈与队列.docx》由会员分享,可在线阅读,更多相关《第三章 栈与队列.docx(10页珍藏版)》请在冰豆网上搜索。
第三章栈与队列
第三章栈与队列
3.15
typedefstruct{
Elemtype*base[2];
Elemtype*top[2];
}BDStacktype;//双向栈类型
StatusInit_Stack(BDStacktype&tws,intm)//初始化一个大小为m的双向栈tws
{
tws.base[0]=(Elemtype*)malloc(sizeof(Elemtype));
tws.base[1]=tws.base[0]+m;
tws.top[0]=tws.base[0];
tws.top[1]=tws.base[1];
returnOK;
}//Init_Stack
Statuspush(BDStacktype&tws,inti,Elemtypex)//x入栈,i=0表示低端栈,i=1表示高端栈
{
if(tws.top[0]>tws.top[1])returnOVERFLOW;//注意此时的栈满条件
if(i==0)*tws.top[0]++=x;
elseif(i==1)*tws.top[1]--=x;
elsereturnERROR;
returnOK;
}//push
Statuspop(BDStacktype&tws,inti,Elemtype&x)//x出栈,i=0表示低端栈,i=1表示高端栈
{
if(i==0)
{
if(tws.top[0]==tws.base[0])returnOVERFLOW;
x=*--tws.top[0];
}
elseif(i==1)
{
if(tws.top[1]==tws.base[1])returnOVERFLOW;
x=*++tws.top[1];
}
elsereturnERROR;
returnOK;
}//pop
3.16
voidTrain_arrange(char*train)//这里用字符串train表示火车,'H'表示硬席,'S'表示软席
{
p=train;q=train;
InitStack(s);
while(*p)
{
if(*p=='H')push(s,*p);//把'H'存入栈中
else*(q++)=*p;//把'S'调到前部
p++;
}
while(!
StackEmpty(s))
{
pop(s,c);
*(q++)=c;//把'H'接在后部
}
}//Train_arrange
3.17
intIsReverse()//判断输入的字符串中'&'前和'&'后部分是否为逆串,是则返回1,否则返回0
{
InitStack(s);
while((e=getchar())!
='&')
push(s,e);
while((e=getchar())!
='@')
{
if(StackEmpty(s))return0;
pop(s,c);
if(e!
=c)return0;
}
if(!
StackEmpty(s))return0;
return1;
}//IsReverse
3.18
StatusBracket_Test(char*str)//判别表达式中小括号是否匹配
{
count=0;
for(p=str;*p;p++)
{
if(*p=='(')count++;
elseif(*p==')')count--;
if(count<0)returnERROR;
}
if(count)returnERROR;//注意括号不匹配的两种情况
returnOK;
}//Bracket_Test
3.19
StatusAllBrackets_Test(char*str)//判别表达式中三种括号是否匹配
{
InitStack(s);
for(p=str;*p;p++)
{
if(*p=='('||*p=='['||*p=='{')push(s,*p);
elseif(*p==')'||*p==']'||*p=='}')
{
if(StackEmpty(s))returnERROR;
pop(s,c);
if(*p==')'&&c!
='(')returnERROR;
if(*p==']'&&c!
='[')returnERROR;
if(*p=='}'&&c!
='{')returnERROR;//必须与当前栈顶括号匹配
}
}//for
if(!
StackEmpty(s))returnERROR;
returnOK;
}//AllBrackets_Test
3.20
typedefstruct{
.intx;
inty;
}coordinate;
voidRepaint_Color(intg[m][n],inti,intj,intcolor)//把点(i,j)相邻区域的颜色置换为color
{
old=g[i][j];
InitQueue(Q);
EnQueue(Q,{I,j});
while(!
QueueEmpty(Q))
{
DeQueue(Q,a);
x=a.x;y=a.y;
if(x>1)
if(g[x-1][y]==old)
{
g[x-1][y]=color;
EnQueue(Q,{x-1,y});//修改左邻点的颜色
}
if(y>1)
if(g[x][y-1]==old)
{
g[x][y-1]=color;
EnQueue(Q,{x,y-1});//修改上邻点的颜色
}
if(x if(g[x+1][y]==old)
{
g[x+1][y]=color;
EnQueue(Q,{x+1,y});//修改右邻点的颜色
}
if(y if(g[x][y+1]==old)
{
g[x][y+1]=color;
EnQueue(Q,{x,y+1});//修改下邻点的颜色
}
}//while
}//Repaint_Color
分析:
本算法采用了类似于图的广度优先遍历的思想,用两个队列保存相邻同色点的横坐标和纵坐标.递归形式的算法该怎么写呢?
3.21
voidNiBoLan(char*str,char*new)//把中缀表达式str转换成逆波兰式new
{
p=str;q=new;//为方便起见,设str的两端都加上了优先级最低的特殊符号
InitStack(s);//s为运算符栈
while(*p)
{
if(*p是字母))*q++=*p;//直接输出
else
{
c=gettop(s);
if(*p优先级比c高)push(s,*p);
else
{
while(gettop(s)优先级不比*p低)
{
pop(s,c);*(q++)=c;
}//while
push(s,*p);//运算符在栈内遵循越往栈顶优先级越高的原则
}//else
}//else
p++;
}//while
}//NiBoLan//参见编译原理教材
3.22
intGetValue_NiBoLan(char*str)//对逆波兰式求值
{
p=str;InitStack(s);//s为操作数栈
while(*p)
{
if(*p是数)push(s,*p);
else
{
pop(s,a);pop(s,b);
r=compute(b,*p,a);//假设compute为执行双目运算的过程
push(s,r);
}//else
p++;
}//while
pop(s,r);returnr;
}//GetValue_NiBoLan
3.23
StatusNiBoLan_to_BoLan(char*str,stringtype&new)//把逆波兰表达式str转换为波兰式new
{
p=str;Initstack(s);//s的元素为stringtype类型
while(*p)
{
if(*p为字母)push(s,*p);
else
{
if(StackEmpty(s))returnERROR;
pop(s,a);
if(StackEmpty(s))returnERROR;
pop(s,b);
c=link(link(*p,b),a);
push(s,c);
}//else
p++;
}//while
pop(s,new);
if(!
StackEmpty(s))returnERROR;
returnOK;
}//NiBoLan_to_BoLan
分析:
基本思想见书后注释.本题中暂不考虑串的具体操作的实现,而将其看作一种抽象数据类型stringtype,对其可以进行连接操作:
c=link(a,b).
3.24
Statusg(intm,intn,int&s)//求递归函数g的值s
{
if(m==0&&n>=0)s=0;
elseif(m>0&&n>=0)s=n+g(m-1,2*n);
elsereturnERROR;
returnOK;
}//g
3.25
StatusF_recursive(intn,int&s)//递归算法
{
if(n<0)returnERROR;
if(n==0)s=n+1;
else
{
F_recurve(n/2,r);
s=n*r;
}
returnOK;
}//F_recursive
StatusF_nonrecursive(intn,ints)//非递归算法
{
if(n<0)returnERROR;
if(n==0)s=n+1;
else
{
InitStack(s);//s的元素类型为struct{inta;intb;}
while(n!
=0)
{
a=n;b=n/2;
push(s,{a,b});
n=b;
}//while
s=1;
while(!
StackEmpty(s))
{
pop(s,t);
s*=t.a;
}//while
}
returnOK;
}//F_nonrecursive
3.26
floatSqrt_recursive(floatA,floatp,floate)//求平方根的递归算法
{
if(abs(p^2-A)<=e)returnp;
elsereturnsqrt_recurve(A,(p+A/p)/2,e);
}//Sqrt_recurve
floatSqrt_nonrecursive(floatA,floatp,floate)//求平方根的非递归算法
{
while(abs(p^2-A)>=e)
p=(p+A/p)/2;
returnp;
}//Sqrt_nonrecursive
3.27
这一题的所有算法以及栈的变化过程请参见《数据结构(pascal版)》,作者不再详细写出.
3.28
voidInitCiQueue(CiQueue&Q)//初始化循环链表表示的队列Q
{
Q=(CiLNode*)malloc(sizeof(CiLNode));
Q->next=Q;
}//InitCiQueue
voidEnCiQueue(CiQueue&Q,intx)//把元素x插入循环链表表示的队列Q,Q指向队尾元素,Q->next指向头结点,Q->next->next指向队头元素
{
p=(CiLNode*)malloc(sizeof(CiLNode));
p->data=x;
p->next=Q->next;//直接把p加在Q的后面
Q->next=p;
Q=p; //修改尾指针
}
StatusDeCiQueue(CiQueue&Q,intx)//从循环链表表示的队列Q头部删除元素x
{
if(Q==Q->next)returnINFEASIBLE;//队列已空
p=Q->next->next;
x=p->data;
Q->next->next=p->next;
free(p);
returnOK;
}//DeCiQueue
3.29
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
分析:
当循环队列容量较小而队列中每个元素占的空间较多时,此种表示方法可以节约较多的存储空间,较有价值.
3.30
StatusEnCyQueue(CyQueue&Q,intx)//带length域的循环队列入队算法
{
if(Q.length==MAXSIZE)returnOVERFLOW;
Q.rear=(Q.rear+1)%MAXSIZE;
Q.base[Q.rear]=x;
Q.length++;
returnOK;
}//EnCyQueue
StatusDeCyQueue(CyQueue&Q,int&x)//带length域的循环队列出队算法
{
if(Q.length==0)returnINFEASIBLE;
head=(Q.rear-Q.length+1)%MAXSIZE;//详见书后注释
x=Q.base[head];
Q.length--;
}//DeCyQueue
3.31
intPalindrome_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0
{
InitStack(S);InitQueue(Q);
while((c=getchar()!
='@')
{
Push(S,c);EnQueue(Q,c);//同时使用栈和队列两种结构
}
while(!
StackEmpty(S))
{
Pop(S,a);DeQueue(Q,b));
if(a!
=b)returnERROR;
}
returnOK;
}//Palindrome_Test
3.32
voidGetFib_CyQueue(intk,intn)//求k阶斐波那契序列的前n+1项
{
InitCyQueue(Q);//其MAXSIZE设置为k
for(i=0;i Q.base[k-1]=1;//给前k项赋初值
for(i=0;i for(i=k;i<=n;i++)
{
m=i%k;sum=0;
for(j=0;j Q.base[m]=sum;//求第i项的值存入队列中并取代已无用的第一项
printf("%d",sum);
}
}//GetFib_CyQueue
3.33
StatusEnDQueue(DQueue&Q,intx)//输出受限的双端队列的入队操作
{
if((Q.rear+1)%MAXSIZE==Q.front)returnOVERFLOW;//队列满
avr=(Q.base[Q.rear-1]+Q.base[Q.front])/2;
if(x>=avr)//根据x的值决定插入在队头还是队尾
{
Q.base[Q.rear]=x;
Q.rear=(Q.rear+1)%MAXSIZE;
}//插入在队尾
else
{
Q.front=(Q.front-1)%MAXSIZE;
Q.base[Q.front]=x;
}//插入在队头
returnOK;
}//EnDQueue
StatusDeDQueue(DQueue&Q,int&x)//输出受限的双端队列的出队操作
{
if(Q.front==Q.rear)returnINFEASIBLE;//队列空
x=Q.base[Q.front];
Q.front=(Q.front+1)%MAXSIZE;
returnOK;
}//DeDQueue
3.34
voidTrain_Rearrange(char*train)//这里用字符串train表示火车,'P'表示硬座,'H'表示硬卧,'S'表示软卧,最终按PSH的顺序排列
{
r=train;
InitDQueue(Q);
while(*r)
{
if(*r=='P')
{
printf("E");
printf("D");//实际上等于不入队列,直接输出P车厢
}
elseif(*r=='S')
{
printf("E");
EnDQueue(Q,*r,0);//0表示把S车厢从头端入队列
}
else
{
printf("A");
EnDQueue(Q,*r,1);//1表示把H车厢从尾端入队列
}
}//while
while(!
DQueueEmpty(Q))
{
printf("D");
DeDQueue(Q);
}//while//从头端出队列的车厢必然是先S后H的顺序
}//Train_Rearrange