演示堆栈过程.docx

演示堆栈过程.docx

《演示堆栈过程.docx》由会员分享，可在线阅读，更多相关《演示堆栈过程.docx（18页珍藏版）》请在冰豆网上搜索。

演示堆栈过程

#include

#include

#include

#include

#defineMAX100

charstock[MAX];

inttop=-1;

chara[MAX],b[MAX];

charexp[100];

intoperand1=0;//定义操作数

intoperand2=0;//定义操作数

intresult=0;//定义操作结果变量

intpos=0;//目前表达式位置

//定义一个节点的结构

typedefstructnode

{

intmember;//数据域

structnode*pNext;//指针域

}Node,*pNode;

//定义一个栈结构

typedefstructstack

{

pNodeTop;//栈顶

pNodeBottom;//栈底

}Stack,*pStack;

voidInitStack（pStack）;//初始化栈的函数

boolPush（pStack,char）;//进行入栈操作的函数

voidTraverseStack（pStack）;//遍历栈函数

boolEmpty（pStack）;//判断栈是否为空的函数

intPop（pStack）;//进行出栈操作的函数

voidClear（pStack）;//清空栈的函数

voidcaidan（）;//显示菜单

voidfun（chara[],charb[]）;//中序转后序函数

intmain（void）

{

Stacks;//定义一个栈

charc;

inti;

intnum;

chardata;//临时保存用户输入的数据

charre_num;//保存Pop函数的返回值

printf（"**************************************\n"）;

printf（"*1—初始化栈*\n"）;

printf（"*2—入栈*\n"）;

printf（"*3—出栈*\n"）;

printf（"*4—遍历栈中元素并显示栈顶元素*\n"）;

printf（"*5—清空栈*\n"）;

printf（"*6—栈的中序转后序*\n"）;

printf（"*7—栈后序表达式的计算*\n"）;

printf（"*8—退出程序*\n"）;

printf（"*9—显示菜单*\n"）;

printf（"**************************************\n"）;

while

（1）

{

printf（"请选择你要进行的操作:

"）;

intk;

scanf（"%d",&k）;

switch（k）

{

case1:

InitStack（&s）;break;

case2:

printf（"请输入你准备输入数据的个数:

"）;

scanf（"%d",&num）;

for（i=0;i

{

printf（"第%d个字符：

",i+1）;

getchar（c）;

scanf（"%c",&data）;

if（Push（&s,data））//调用Push函数

{

continue;

}

else

{

printf（"进行进栈操作失败！

\n"）;

exit（-1）;

}

};break;

case3:

printf（"请输入你准备出出栈的字符个数:

"）;

scanf（"%d",&data）;

if（Empty（&s））//判断栈是否为空，为空就不能进行出栈操作

{

printf（"栈已为空!

\n"）;

}

else

{

printf（"你去掉的数字是：

"）;

for（i=0;i

{

re_num=Pop（&s）;//调用Pop函数，并把返回值赋给re_num;

printf（"%c",re_num）;

};

}

printf（"\n"）;break;

case4:

TraverseStack（&s）;break;

case5:

Clear（&s）;break;

case6:

printf（"请输入一个字符串：

"）;

scanf（"%s",a）;

voidfun（chara[],charb[]）;

fun（a,b）;

printf（"\n"）;

break;

case7:

printf（"\t\n请输入后缀表达式：

"）;

gets（exp）;//cin.getline（exp,81）//读取后缀表达式

printf（"\t\n\n后缀表达式[%s]的结果是：

",exp）;

while（exp[pos]!

='\0'&&exp[pos]!

='\n'）//分析表达式字符串

{

if（isoperator（exp[pos]））//是运算符，取两个操作数

{

pop（&operand2）;

pop（&operand1）;

push（getvalue（exp[pos],operand1,operand2））;}

else

push（exp[pos]-48）;//是操作数，压入操作数栈

pos++;//移到下一个字符串位置

}

pop（&result）;//弹出结果

printf（"%d\n",result）;//输出

};

case8:

caidan（）;break;

case9:

printf（"程序结束!

"）;break;

}

}

printf（"\n"）;

return0;

}

//进行栈的初始化的函数

voidInitStack（pStackps）

{

ps->Top=（pNode）malloc（sizeof（Node））;//分配内存空间给栈顶

if（NULL==ps->Top）

{

printf（"动态分配内存失败\n"）;

exit（-1）;

}

else

{

ps->Bottom=ps->Top;//使栈底也指向栈顶空间

ps->Top->pNext=NULL;//栈顶指针置为NULL；

}

printf（"栈已经进行了初始化!

"）;

printf（"\n"）;

return;

}

//进行入栈操作的函数

boolPush（pStackps,chardata）

{

pNodepNew=（pNode）malloc（sizeof（Node））;//定义一个新节点，并分配内存空间

if（NULL==pNew）

{

returnfalse;

}

pNew->member=data;//把要进栈的数据赋给新节点的member成员

pNew->pNext=ps->Top;//使新节点的指针指向栈顶

ps->Top=pNew;//把新节点作为新栈顶

printf（"\n"）;

returntrue;

}

//遍历栈的函数

voidTraverseStack（pStackps）

{

pNodepNew=ps->Top;

if（Empty（ps））//判断栈是否为空，为空就不能进行出栈操作

{

printf（"栈已为空!

\n"）;

}

else

{

printf（"栈顶元素为:

"）;

printf（"%c\n",pNew->member）;

printf（"栈内的元素有:

"）;

while（pNew!

=ps->Bottom）//只要栈顶不等于栈底，循环

{

printf（"%c",pNew->member）;//打印栈顶的成员member

pNew=pNew->pNext;//栈顶指针向下移动一次

}

}

printf（"\n"）;

return;

}

//判断栈是否为空

boolEmpty（pStackps）

{

if（ps->Top==ps->Bottom）//栈顶等于栈底，不就是栈中没数据么

{

returntrue;

}

else

{

returnfalse;

}

printf（"\n"）;

}

//进行出栈操作函数

intPop（pStackps）

{

pNodepSwap=NULL;

intreturn_val;

if（Empty（ps））//判断栈是否为空，为空就不能进行出栈操作

{

printf（"\n栈中数据不足无法完整出栈!

\n"）;

}

else

{

return_val=ps->Top->member;//把栈顶的成员member的值赋给return_val做为函数返回值

pSwap=ps->Top;//使pSwap指向栈顶

ps->Top=ps->Top->pNext;//使栈顶指向栈顶下一个节点

free（pSwap）;//释放以前的栈顶空间

returnreturn_val;

}

printf（"\n"）;

}

//清空栈的函数

voidClear（pStackps）

{

pNodepNew=NULL;

while（ps->Top!

=ps->Bottom）//栈顶和栈底不等，循环

{

pNew=ps->Top;//使一个新节点和栈顶指向同一空间

ps->Top=ps->Top->pNext;//使栈顶指向栈顶的下一个节点

free（pNew）;//释放掉以前的栈顶空间

}

printf（"栈已清空!

\n"）;

return;

}

//显示菜单函数

voidcaidan（）

{

printf（"**************************************\n"）;

printf（"*1—初始化栈*\n"）;

printf（"*2—入栈*\n"）;

printf（"*3—出栈*\n"）;

printf（"*4—遍历栈中元素并显示栈顶元素*\n"）;

printf（"*5—清空栈*\n"）;

printf（"*6—栈的中序转后序*\n"）;

printf（"*7—栈后序表达式的计算*\n"）;

printf（"*8—退出程序*\n"）;

printf（"*9—显示菜单*\n"）;

printf（"**************************************\n"）;

}

//中序转后序函数

voidfun（chara[],charb[]）

{inti,len,j;

len=strlen（a）;

j=-1;

for（i=0;i

{

switch（a[i]）

{

case'（':

stock[++top]='（';break;

case'-':

case'+':

while（top>=0&&stock[top]!

='（'）

b[++j]=stock[top--];

stock[++top]='';

stock[++top]=a[i];

break;

case'*':

case'/':

while（top>=0&&stock[top]!

='（'&&stock[top]!

='+'&&stock[top]!

='-'）

b[++j]=stock[top--];

stock[++top]='';

stock[++top]=a[i];

break;

case'）':

while（stock[top]!

='（'）

b[++j]=stock[top--];

top--;

break;

default:

b[++j]=a[i];

if（i==len-1）

{

b[++j]='';

break;

}

else

if（a[i+1]<='0'||a[i+1]>='9'）

{

b[++j]='';

}

}

}

while（top>=0）

b[++j]=stock[top--];

b[++j]='\0';

for（i=0;i<=j;i++）

printf（"%c",b[i]）;

}

intgetvalue（intop,intoperand1,intoperand2）//计算表达式值

{

charexp[100];

intoperand1=0;//定义操作数

intoperand2=0;//定义操作数

intresult=0;//定义操作结果变量

intpos=0;//目前表达式位置

switch（（char）op）

{

case'*':

return（operand1*operand2）;

case'/':

return（operand1/operand2）;

case'+':

return（operand1+operand2）;

case'-':

return（operand1-operand2）;

}

}

演示堆栈过程

#include

#include

#include

#include

voidPush（intd）;

intPop（void）;

intmain（void）

{

intvalue;

charstr[100];

do

{

printf（"Entervalue"）;

gets（str）;

if（strcmp（str,"pop"）!

=0）

{

value=atoi（str）;

Push（value）;

}

else

{

printf（"valueontopis%d\n",Pop（））;

}

}

while（strcmp（str,"quit"）!

=0）;

system（"PAUSE"）;

return0;

}

#defineMAXSIZE100

intbottomSP=0;

intsp=0;

intstack[MAXSIZE];

voidPush（intd）

{

sp++;

if（sp>=（bottomSP+MAXSIZE））;

{

puts（"StackOverflow.\n"）;

exit

（1）;

}

stack[sp]=d;

}

intPop（void）

{

if（sp<=bottomSP）

{

puts（"Stackunderflow.\n"）;

exit

（1）;

}

system（"PAUSE"）;

returnstack[sp--];

}

题目：

后缀表达式求值

#include#includestructnode//栈结构声明{intdata;//数据域structnode*next;//指针域};

typedefstructnodestacklist;//链表新类型

typedefstacklist*link;//链表指新针类型

linkoperand=NULL;//操作数栈指针

voidpush（intvalue）//进栈，存入数据

{linknewnode;//新结点指针

newnode=newstacklist;//分配新结点

if（!

newnode）

{

printf（"分配失败！

"）;//存入失败

return;

}

newnode->data=value;//创建结点的内容

newnode->next=operand;

operand=newnode;//新结点成为栈的开始

return;

}

voidpop（int*value）//出栈，取出数据{

linktop;//指向栈顶

if（operand!

=NULL）{

top=operand;//指向栈顶

operand=operand->next;//移动栈顶指针，指向下一个结点

*value=top->data;//取数据

deletetop;//吸收结点

}

else

*value=-1;

}

intempty（）//判栈空

{《实用数据结构基础》实验报告-3-

if（operand!

=NULL）return1;

elsereturn0;

}

intisoperator（charop）//判运算符

{

switch（op）

{

case'+':

case'-':

case'*':

case'/':

return1;//是运算符，返回

default:

return0;//不是运算符，返回

}

}

intgetvalue（intop,intoperand1,intoperand2）//计算表达式值

{

switch（（char）op）

{

case'*':

return（operand1*operand2）;

case'/':

return（operand1/operand2）;

case'+':

return（operand1+operand2）;

case'-':

return（operand1-operand2）;

}

}

voidmain（）//主函数

{

charexp[100];

intoperand1=0;//定义操作数

intoperand2=0;//定义操作数

intresult=0;//定义操作结果变量

intpos=0;//目前表达式位置

printf（"\t\n请输入后缀表达式：

"）;

gets（exp）;//cin.getline（exp,81）//读取后缀表达式

printf（"\t\n\n后缀表达式[%s]的结果是：

",exp）;

while（exp[pos]!

='\0'&&exp[pos]!

='\n'）//分析表达式字符串

{

if（isoperator（exp[pos]））//是运算符，取两个操作数

{

pop（&operand2）;

pop（&operand1）;

push（getvalue（exp[pos],operand1,operand2））;}

else

push（exp[pos]-48）;//是操作数，压入操作数栈

pos++;//移到下一个字符串位置

}

pop（&result）;//弹出结果-4-

printf（"%d\n",result）;//输出

}