数据结构栈或队列的基本操作.docx
《数据结构栈或队列的基本操作.docx》由会员分享，可在线阅读，更多相关《数据结构栈或队列的基本操作.docx（20页珍藏版）》请在冰豆网上搜索。
数据结构栈或队列的基本操作
实验目的：
1.实验设置基本要求：
通过实验掌握栈或队列的基本操作的实现，并能灵活运用栈或队列特性，综合运用程序设计、算法分析等知识解决实际问题。
2.实验设置较高要求：
理解组成递归算法的基本条件，理解递归算法与相应的非递归算法的区别，理解栈和队列的应用与作用。
实验内容：
1．十进制数N进制数据的转换（实验类型：
综合型）
1）问题描述：
将从键盘输入的十进制数转换为N（如二进制、八进制、十六进制）进制数据。
2）实验要求:
利用顺序栈实现数制转换问题
3）实现提示：
✧转换方法利用辗转相除法;
✧所转换的N进制数按低位到高位的顺序产生，而通常的输出是从高位到低位的，恰好与计算过程相反，因此转换过程中每得到一位N进制数则进栈保存，转换完毕后依次出栈则正好是转换结果。
4）注意问题:
✧何时入栈、出栈
✧算法结束条件
2．算术表达式求值演示（实验类型：
综合型）
1）问题描述：
从键盘输入一个算术表达式并输出它的结果
2）实验要求：
算术表达式可包含加、减、乘、除、十进制整数和小括号，利用栈实现。
3）实现提示：
✧表达式作为一个串存储，如表达式“3*2-（4+2*1）”,其求值过程为：
自左向右扫描表达式，当扫描到3*2时不能马上计算，因后面可能还有更高的运算，正确的处理过程是：
⏹需要两个栈：
对象栈OPND和算符栈OPTR;
⏹自左至右扫描表达式,若当前字符是运算对象，入OPND栈;
⏹对运算符，若这个运算符比栈顶运算符高则入栈，继续向后处理，若这个运算符比栈顶运算符低则从OPND栈出栈两个数，从OPTR栈出栈一运算符进行运算，并将其运算结果入OPND栈，继续处理当前字符，直到遇到结束符。
4）注意问题
✧重点理解栈的算法思想，能够根据实际情况选择合适的存储结构。
✧注意算法的各个函数之间值的传递情况。
3．停车场管理问题（实验类型：
综合型）
1）问题描述：
设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。
车辆按到达停车场的早晚依次从停车场最里面向大门口处停放（最先到达的第一辆车放在停车场的最里面）。
如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车走开，则排在便道上的第一辆车就进入停车场。
停车场内如有某辆车要开走，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。
每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。
如果停留在便道上的车未进停车场就要离去，允许其离去，不收停车费，并且仍然保持在便道上等待的车辆的次序。
编写程序模拟该停车场的管理。
2）实验要求:
要求程序输出每辆车到达后的停车位置（停车场或便道上），以及某辆车离开停车场时应缴纳的费用和他在停车场内停留的时间
3）实现提示：
以栈模拟停车场，以队列模拟便道，按照从终端读入的车辆“到达”“离开”信息模拟停车场管理
4）注意问题
✧重点理解栈、队列的算法思想，能够根据实际情况选择合适的存储结构。
✧栈、队列的算法是后续实验的基础（广义表、树、图、查找、排序等）。
4．判断“回文”问题（实验类型：
综合型）
1）问题描述：
所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。
例如，did;pop;Iwasable与elbasawI等等。
2）实验要求：
编写程序，利用栈结构判断一个字符串是否是“回文”。
3）实现提示：
✧从左向右遇到的字符，若和栈顶元素比较，若不相等，字符入栈，若相等，出栈。
如此继续，若栈空，字符串是“回文”，否则不是。
5．用递归和非递归两种方法实现自然数的拆分（实验类型：
综合型）
1）问题描述：
任何大于1的自然数n，总可以拆分成若干大于等于1的自然数之和。
例:
n=44=1+34=1+1+24=1+1+1+14=2+2
2）实验要求:
✧采用递归和非递归两种方法实现
✧利用交换率得出的拆分看作相同的拆分。
3）实现提示：
✧递归算法:
⏹用数组a[]，a[k]中存储已完成的一种拆分
⏹a[k]能否再拆分取决于a[k]/2是否大于等于a[k-1]；
⏹递归过程有两个参数：
n表示要拆分数值的大小；k表示n存储在数组元素a[k]中。
✧非递归算法：
（1）栈为两个数组a[],b[]，ax,bx表示两个栈的栈顶元素；初始化：
a[1]=1,b[1]=n，i=1,ax=a[i],bx=b[i]
（2）若i<>1orax<>bx,重复
◆若ax（2）
i=i+1;a[i]=ax,b[i]=bx-ax,bx=b[i]
◆若ax=bx，则数出拆分，退栈兵修改栈顶元素，返回
（2）
i=i-1;a[i]=a[i]+1,ax=a[i],bx=b[i]
◆其余情况，bx/2（2）
a[i]=a[i]+1,ax=a[i]
实验内容（应包括实验题目、实验要求、实验任务等）
附录（可包括源程序清单或其它说明）
实验源程序代码如下：
第一题：
#include
#include
#include
#defineStackSize100
typedefintStackType;
typedefstruct{
StackTypedata[StackSize];
inttop;
}Seq_stack;
Seq_stack*Creatstack（）
{
Seq_stack*s;
s=（Seq_stack*）malloc（sizeof（Seq_stack））;
if（s!
=NULL）
{
s->top=-1;
returns;
}
else
{
cout<<"申请内存失败!
"<exit（0）;
}
}
/*voidIf_Empty（Seq_stack*s）///////////////////判断是否为空栈
{
if（s->top==-1）
cout<<"此栈为空栈!
"<else
cout<<"此栈不是空栈!
"<}*/
voidPush（Seq_stack*s,StackTypem）//////////////////入栈操作
{
if（s->top==StackSize-1）
{
cout<<"此栈已满终止程序!
!
"<exit（0）;
}
else
{
s->top++;
s->data[s->top]=m;
}
}
StackTypePop（Seq_stack*s）
{
StackTypetemp;
if（s->top==-1）
{
cout<<"此栈为空栈!
程序终止"<exit（0）;
}
else
{
temp=s->data[s->top];
s->top--;
returntemp;
}
}
voidconver（intN,inti）////数制转换
{
Seq_stack*s;
StackTypem;
s=Creatstack（）;
while（N）
{
Push（s,N%i）;///////余数存入栈
N=N/i;/////商作为被除数继续循环
}
while（s->top>-1）
{
m=Pop（s）;
cout<}
cout<}
voidmain（）
{
intN,i,j;
for（;;）
{
cout<<"请输入要进行转换的十进制整数:
"<cin>>N;
cout<<"请输入将要转换成几进制数"<cin>>i;
cout<<"您将要转换成"<conver（N,i）;
cout<<"是否继续？
1.是2.退出"<cin>>j;
if（j==2）
break;
else
continue;
}
}
第二题：
#include
#include
#include
typedefintStackType;
typedefstructNode{
StackTypedata;
structNode*next;
}Stack_node;
intpriority[8][8]={
3,3,1,1,1,1,3,3,
3,3,1,1,1,1,3,3,
3,3,3,3,3,1,3,3,
3,3,3,3,3,1,3,3,
3,3,3,3,3,1,3,3,
1,1,1,1,1,1,2,2,
3,3,3,3,3,0,2,2,
1,1,1,1,1,1,0,2};
Stack_node*Push（Stack_node*t,StackTypem）//////////////创建同时进行入栈操作
{
Stack_node*s;
s=（Stack_node*）malloc（sizeof（Stack_node））;
if（s）
{
s->data=m;//////m入栈
s->next=t;
t=s;
}
else
{
cout<<"内存不足，程序终止"<exit（0）;
}
returnt;
}
Stack_node*Pop（Stack_node*t,StackType*n）
{
Stack_node*temp;
if（!
t）
{
cout<<"此栈为空，出栈操作失败!
!
"<returnNULL;
}
else
{
temp=t;
*n=t->data;
t=t->next;
free（temp）;///释放删除节点所占内存空间
returnt;
}
}
StackTypeGet_top（Stack_node*t）///////读取栈中数据
{
if（!
t）
{
cout<<"此栈为空，无法读取!
!
"<return0;
}
else
returnt->data;
}
intsub（StackTypex）
{
switch（x）
{
case'+':
return0;
case'-':
return1;
case'*':
return2;
case'/':
return3;
case'%':
return4;
case'（':
return5;
case'）':
return6;
case'#':
return7;
}
}
voidmain（）
{
StackTypex1,x2,i,j,op,temp;
charch;
Stack_node*OPTR=NULL;////算符栈
Stack_node*OPND=NULL;////对象栈
OPTR=Push（OPTR,'#'）;////将开始符号“#”压入栈中；
cout<<"请输入要进行的运算表达式:
"<ch=getchar（）;
while（!
（ch=='#'&&Get_top（OPTR）=='#'））
{
if（ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='%'||ch=='（'||ch=='）'||ch=='#'）
{
i=sub（Get_top（OPTR））;
j=sub（ch）;
if（priority[i][j]==3）
{
OPTR=Pop（OPTR,&op）;
OPND=Pop（OPND,&x2）;
OPND=Pop（OPND,&x1）;
switch（op）
{
case'+':
OPND=Push（OPND,x1+x2）;
break;
case'-':
OPND=Push（OPND,x1-x2）;
break;
case'*':
OPND=Push（OPND,x1*x2）;
break;
case'/':
OPND=Push（OPND,x1/x2）;
break;
case'%':
OPND=Push（OPND,x1%x2）;
}
continue;
}
if（priority[i][j]==1）////栈内运算符优先级小于栈外运算符优先级
OPTR=Push（OPTR,ch）;
if（priority[i][j]==2）
OPTR=Pop（OPTR,&temp）;
}
else
OPND=Push（OPND,ch-48）;////将数字字符转换为数字压入栈中
ch=getchar（）;
}
cout<<"表达式的值为:
"<}
第三题：
#include
#include
#defineMAX100
typedefstructStack
{
intdata[MAX];
inttop;
}carstop;
carstop*creat（）
{
carstop*S;
S=（Stack*）malloc（sizeof（Stack））;
if（S!
=NULL）
{
S->top=-1;
returnS;
}
}
carstop*push（carstop*s,intx）
{
s->top++;
s->data[s->top]=x;
returns;
}
intpop（carstop*s）
{
inttemp;
chart;
while（s->top!
=-1）
{
temp=s->data[s->top];
s->top--;
if（temp>9）
{
temp=（65-10）+temp;
t=（char）temp;
cout<}
else
cout<}
returntemp;
}
carstop*stack1（carstop*s,intx）
{
inttemp1=1;
inttemp2;
while（temp1!
=0）
{
temp1=x/2;
temp2=x%2;
x=temp1;
s=push（s,temp2）;
}
returns;
}
Stack*stack2（Stack*s,intx）
{
inttemp1=1;
inttemp2;
while（temp1!
=0）
{
temp1=x/8;
temp2=x%8;
x=temp1;
s=push（s,temp2）;
}
returns;
}
carstop*stack3（Stack*s,intx）
{
inttemp1=1;
inttemp2;
while（temp1!
=0）
{
temp1=x/16;
temp2=x%16;
x=temp1;
s=push（s,temp2）;
}
returns;
}
voidmain（）
{
inta,b;
carstop*P;
P=creat（）;
cout<<"请输入数字"<cin>>a;
P=stack3（P,a）;
pop（P）;
P=stack1（P,a）;
pop（P）;
P=stack2（P,a）;
pop（P）;
}
第四题：
#include
#include
#include
#include
#defineN20
typedefstructstack
{
chardata[N];
inttop;
};
stack*creat（）
{
stack*S;
S=（stack*）malloc（sizeof（stack））;
S->top=-1;
returnS;
}
stack*push（stack*S,chara）
{
S->top++;
S->data[S->top]=a;
returnS;
}
stack*pop（stack*S）
{
chara;
a=S->data[S->top];
S->top--;
returnS;
}
voidmain（）
{
chars[N];
stack*S;
S=creat（）;
cout<<"请输入内容:
"<cin>>s;
for（inti=0;s[i]!
='\0';i++）
{
push（S,s[i]）;
}
for（i;s[i]!
='\0';i--）
{
if（s[i]==S->data[S->top]）
pop（S）;
else
continue;
}
if（S->top==-1）
cout<<"是回文!
!
"<else
cout<<"不是回文!
!
"<}
第五题：
（参考别人的）
#include
#include
#include
#defineStackInitSize50
typedefintStackElementType;
typedefstruct{
StackElementTypea[StackInitSize];
StackElementTypeb[StackInitSize];
inttop;
}SeqStack;
SeqStack*InitStack（）
{
SeqStack*s;
s=（SeqStack*）malloc（sizeof（SeqStack））;
if（s!
=NULL）
{
s->top=-1;
returns;
}else{
printf（"没有足够的内存空间，申请失败，程序运行终止！
\n"）;
exit（0）;
}
}
voidDestoryStack（SeqStack*s）
{
free（s）;
printf（"栈已销毁！
\n"）;
}
voidPush（SeqStack*s,StackElementTypex,StackElementTypey）
{
if（s->top==StackInitSize）
{
printf（"栈满！
程序运行终止！
\n"）;
exit（0）;
}
else{
s->top++;
s->a[s->top]=x;
s->b[s->top]=y;
}
}
StackElementTypePop（SeqStack*s）
{
StackElementTypetemp1,temp2;
temp1=s->a[s->top];
temp2=s->b[s->top];
s->top--;
return0;
}
StackElementTypeGetTop（SeqStack*s,StackElementType*elem1,StackElementType*elem2）
{
*elem1=s->a[s->top];
*elem2=s->b[s->top];
return0;
}
intmain（）
{
intx,y,n,k2,k3,a;
intsum=0;
intb=0;
intk1[50];
cout<<"请输入需要拆分的数:
"<cin>>n;
cout<<"拆分的结果为:
"<SeqStack*s;
s=InitStack（）;
Push（s,1,n）;
for（inti=0;;i++）
{
GetTop（s,&x,&y）;
if（x{
Push（s,x,y-x）;
GetTop（s,&k1[i],&k2）;
b++;
cout<for（intj=0;j<=i;j++）
cout<cout<}
elseif（x==y/2.0）
{
Push（s,x,y-x）;
GetTop（s,&k1[i],&k2）;
cout<for（intj=0;j<=i;j++）
cout<cout<Pop（s）;
for（;;）
{
GetTop（s,&a,&k3）;
if（k3<=n/2）
{
for（intt=0;t<=b-1;t++）
sum+=k1[t];
s->a[s->top]=sum;
cout<Pop（s）;
b--;
sum=0;
}elsebreak;
}break;
}
}
return0;
}
////第五题代码参考其他同学的，已理解。
升级会员 