数据结构栈或队列的基本操作文档格式.docx
《数据结构栈或队列的基本操作文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构栈或队列的基本操作文档格式.docx（20页珍藏版）》请在冰豆网上搜索。
✧栈、队列的算法是后续实验的基础（广义表、树、图、查找、排序等）。
4．判断“回文”问题（实验类型：
所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。
例如，did;
pop;
Iwasable与elbasawI等等。
编写程序，利用栈结构判断一个字符串是否是“回文”。
✧从左向右遇到的字符，若和栈顶元素比较，若不相等，字符入栈，若相等，出栈。
如此继续，若栈空，字符串是“回文”，否则不是。
5．用递归和非递归两种方法实现自然数的拆分（实验类型：
任何大于1的自然数n，总可以拆分成若干大于等于1的自然数之和。
例:
n=44=1+34=1+1+24=1+1+1+14=2+2
✧采用递归和非递归两种方法实现
✧利用交换率得出的拆分看作相同的拆分。
✧递归算法:
⏹用数组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<
bx/2，进栈并取栈顶元素，返回
（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<
ax<
bx，修改栈顶元素，返回
（2）
a[i]=a[i]+1,ax=a[i]
实验内容（应包括实验题目、实验要求、实验任务等）
附录（可包括源程序清单或其它说明）
实验源程序代码如下：
第一题：
#include<
stdio.h>
stdlib.h>
#include<
iostream.h>
#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<
<
"
申请内存失败!
endl;
exit（0）;
}
/*voidIf_Empty（Seq_stack*s）///////////////////判断是否为空栈
if（s->
top==-1）
此栈为空栈!
此栈不是空栈!
}*/
voidPush（Seq_stack*s,StackTypem）//////////////////入栈操作
top==StackSize-1）
此栈已满终止程序!
!
top++;
data[s->
top]=m;
StackTypePop（Seq_stack*s）
StackTypetemp;
程序终止"
temp=s->
top];
top--;
returntemp;
voidconver（intN,inti）////数制转换
StackTypem;
s=Creatstack（）;
while（N）
Push（s,N%i）;
///////余数存入栈
N=N/i;
/////商作为被除数继续循环
while（s->
top>
-1）
m=Pop（s）;
m;
cout<
voidmain（）
intN,i,j;
for（;
;
）
请输入要进行转换的十进制整数:
cin>
N;
请输入将要转换成几进制数"
i;
您将要转换成"
i<
进制数"
conver（N,i）;
是否继续？
1.是2.退出"
j;
if（j==2）
break;
else
continue;
第二题：
typedefstructNode{
StackTypedata;
structNode*next;
}Stack_node;
intpriority[8][8]={
3,3,1,1,1,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）
data=m;
//////m入栈
next=t;
t=s;
内存不足，程序终止"
returnt;
Stack_node*Pop（Stack_node*t,StackType*n）
Stack_node*temp;
if（!
t）
此栈为空，出栈操作失败!
returnNULL;
temp=t;
*n=t->
data;
t=t->
next;
free（temp）;
///释放删除节点所占内存空间
returnt;
StackTypeGet_top（Stack_node*t）///////读取栈中数据
此栈为空，无法读取!
return0;
returnt->
intsub（StackTypex）
switch（x）
case'
+'
:
-'
return1;
*'
return2;
/'
return3;
%'
return4;
（'
return5;
）'
return6;
#'
return7;
StackTypex1,x2,i,j,op,temp;
charch;
Stack_node*OPTR=NULL;
////算符栈
Stack_node*OPND=NULL;
////对象栈
OPTR=Push（OPTR,'
）;
////将开始符号“#”压入栈中；
请输入要进行的运算表达式:
ch=getchar（）;
while（!
（ch=='
&
&
Get_top（OPTR）=='
））
if（ch=='
||ch=='
{
i=sub（Get_top（OPTR））;
j=sub（ch）;
if（priority[i][j]==3）
{
OPTR=Pop（OPTR,&
op）;
OPND=Pop（OPND,&
x2）;
x1）;
switch（op）
{
case'
OPND=Push（OPND,x1+x2）;
break;
OPND=Push（OPND,x1-x2）;
OPND=Push（OPND,x1*x2）;
OPND=Push（OPND,x1/x2）;
OPND=Push（OPND,x1%x2）;
}
continue;
}
if（priority[i][j]==1）////栈内运算符优先级小于栈外运算符优先级
OPTR=Push（OPTR,ch）;
if（priority[i][j]==2）
temp）;
}
OPND=Push（OPND,ch-48）;
////将数字字符转换为数字压入栈中
ch=getchar（）;
表达式的值为:
Get_top（OPND）<
第三题：
#defineMAX100
typedefstructStack
intdata[MAX];
}carstop;
carstop*creat（）
carstop*S;
S=（Stack*）malloc（sizeof（Stack））;
if（S!
{
S->
returnS;
carstop*push（carstop*s,intx）
s->
top]=x;
returns;
intpop（carstop*s）
inttemp;
chart;
top!
=-1）
if（temp>
9）
temp=（65-10）+temp;
t=（char）temp;
cout<
t<
temp<
returntemp;
carstop*stack1（carstop*s,intx）
inttemp1=1;
inttemp2;
while（temp1!
=0）
temp1=x/2;
temp2=x%2;
x=temp1;
s=push（s,temp2）;
Stack*stack2（Stack*s,intx）
temp1=x/8;
temp2=x%8;
carstop*stack3（Stack*s,intx）
temp1=x/16;
temp2=x%16;
inta,b;
carstop*P;
P=creat（）;
请输入数字"
cin>
a;
P=stack3（P,a）;
pop（P）;
P=stack1（P,a）;
P=stack2（P,a）;
第四题：
string.h>
#defineN20
typedefstructstack
chardata[N];
};
stack*creat（）
stack*S;
S=（stack*）malloc（sizeof（stack））;
S->
returnS;
stack*push（stack*S,chara）
data[S->
top]=a;
stack*pop（stack*S）
chara;
a=S->
chars[N];
S=creat（）;
请输入内容:
s;
for（inti=0;
s[i]!
='
\0'
i++）
push（S,s[i]）;
for（i;
i--）
if（s[i]==S->
top]）
pop（S）;
if（S->
top==-1）
是回文!
不是回文!
第五题：
（参考别人的）
#defineStackInitSize50
typedefintStackElementType;
StackElementTypea[StackInitSize];
StackElementTypeb[StackInitSize];
}SeqStack;
SeqStack*InitStack（）
SeqStack*s;
s=（SeqStack*）malloc（sizeof（SeqStack））;
}else{
printf（"
没有足够的内存空间，申请失败，程序运行终止！
\n"
voidDestoryStack（SeqStack*s）
free（s）;
printf（"
栈已销毁！
voidPush（SeqStack*s,StackElementTypex,StackElementTypey）
top==StackInitSize）
栈满！
程序运行终止！
else{
a[s->
b[s->
top]=y;
StackElementTypePop（SeqStack*s）
StackElementTypetemp1,temp2;
temp1=s->
temp2=s->
return0;
StackElementTypeGetTop（SeqStack*s,StackElementType*elem1,StackElementType*elem2）
*elem1=s->
*elem2=s->
intmain（）
intx,y,n,k2,k3,a;
intsum=0;
intb=0;
intk1[50];
请输入需要拆分的数:
n;
拆分的结果为:
s=InitStack（）;
Push（s,1,n）;
GetTop（s,&
x,&
y）;
if（x<
y/2.0）
Push（s,x,y-x）;
GetTop（s,&
k1[i],&
k2）;
b++;
n<
="
for（intj=0;
j<
=i;
j++）
cout<
k1[j]<
+"
k2<
elseif（x==y/2.0）
{
Pop（s）;
for（;
GetTop（s,&
a,&
k3）;
if（k3<
=n/2）
for（intt=0;
=b-1;
t++）
sum+=k1[t];
s->
top]=sum;
cout<
sum<
k3<
Pop（s）;
b--;
sum=0;
}elsebreak;
}break;
////第五题代码参考其他同学的，已理解。
升级会员 