栈和队列的应用Word下载.docx

栈和队列的应用Word下载.docx

《栈和队列的应用Word下载.docx》由会员分享，可在线阅读，更多相关《栈和队列的应用Word下载.docx（21页珍藏版）》请在冰豆网上搜索。

#definePRINT_ITEM"

%d"

//定义输出项的宏

#defineSCANF_ITEM"

%d"

//定义输入项的宏

typedefintbool;

//定义bool类型

constbooltrue=1;

//定义bool类型true常量

constboolfalse=0;

//定义bool类型false常量

typedefintELEMTYPE;

//定义元素类型

typedefstructsnode//定义链栈

{

ELEMTYPEdata;

structsnode*next;

}LINKSTACK;

constELEMTYPESTACK_NULL=-9999;

//定义常量栈为NULL的值

LINKSTACK*INITSTACK（）;

//初始化栈

LINKSTACK*CREATESTACK（ELEMTYPE）;

//创建链栈

LINKSTACK*PUSH（LINKSTACK*,ELEMTYPE）;

//进栈操作

ELEMTYPEGETTOP（LINKSTACK*）;

//获取栈顶元素

LINKSTACK*POP（LINKSTACK*）;

//出栈操作

boolEMPTY（LINKSTACK*）;

//判断栈是否为NULL

LINKSTACK*CLEAR（LINKSTACK*）;

//清空链栈

intCURRENT_SIZE（LINKSTACK*）;

//当前链栈中的元素个数

voidPRINT_STACK（LINKSTACK*）;

//打印链栈元素

voidmenu（）;

//菜单

voidprint_enter（）;

//打印回车

voidprint_tab（）;

//打印tab

voidprint_menu_item（char*,char*）;

//打印菜单中的每一项

voidprint_str（char*）;

voidprint_info（char*,bool）;

//打印信息，bool意思是是否打印回车

ELEMTYPEget_input（）;

//获取压栈的数据

LINKSTACK*stack_push（LINKSTACK*）;

//压入链栈

LINKSTACK*stack_pop（LINKSTACK*）;

//出栈

LINKSTACK*stack_get_top（LINKSTACK*）;

//获取栈顶元素

LINKSTACK*stack_empty（LINKSTACK*）;

//判断栈是否为空

LINKSTACK*stack_cur_size（LINKSTACK*）;

//获取栈中的元素个数

LINKSTACK*stack_clear（LINKSTACK*）;

//清空栈中元素

LINKSTACK*link_stack_method（LINKSTACK*,LINKSTACK*（*fun）（LINKSTACK*））;

//定义函数指针

intmain（intargc,char*argv[]）

LINKSTACK*top=NULL;

intselect_menu_value;

menu（）;

do

{

print_info（"

请选择:

"

false）;

scanf（"

&

select_menu_value）;

switch（select_menu_value）

case0:

break;

case7:

case1:

top=link_stack_method（top,stack_push）;

case2:

top=link_stack_method（top,stack_pop）;

case3:

top=link_stack_method（top,stack_get_top）;

case4:

top=link_stack_method（top,stack_empty）;

case5:

top=link_stack_method（top,stack_cur_size）;

case6:

top=link_stack_method（top,stack_clear）;

default:

}

}while（7!

=select_menu_value）;

return0;

}

LINKSTACK*INITSTACK（）

LINKSTACK*stack=malloc（SIZE）;

returnstack;

}

LINKSTACK*CREATESTACK（ELEMTYPEdata）

LINKSTACK*head=INITSTACK（）;

head->

data=data;

returnhead;

LINKSTACK*PUSH（LINKSTACK*top,ELEMTYPEdata）

LINKSTACK*p=CREATESTACK（data）;

if（NULL==top）//当栈为NULL，则将当前的数据存放在栈底

p->

next=NULL;

else

next=top;

top=p;

returntop;

ELEMTYPEGETTOP（LINKSTACK*top）

ELEMTYPEresult=STACK_NULL;

if（top!

=NULL）

result=top->

data;

returnresult;

LINKSTACK*POP（LINKSTACK*top）

LINKSTACK*del;

if（!

EMPTY（top））

del=top;

top=top->

next;

free（del）;

//释放内存

boolEMPTY（LINKSTACK*top）

boolresult=false;

if（top==NULL）

result=true;

LINKSTACK*CLEAR（LINKSTACK*top）

top=CLEAR（top）;

//使用递归进行将栈置空操作

intCURRENT_SIZE（LINKSTACK*top）

intresult=0;

while（top!

result++;

voidPRINT_STACK（LINKSTACK*top）

printf（PRINT_ITEM,top->

data）;

}

voidmenu（）

print_enter（）;

print_tab（）;

print_info（"

链栈"

true）;

print_enter（）;

print_menu_item（"

1"

"

入栈操作"

）;

2"

出栈操作"

3"

获取栈顶元素"

4"

判断栈表是否为空"

5"

栈中元素个数"

6"

清空栈表"

0"

返回到选择菜单"

7"

退出程序"

voidprint_enter（）

printf（"

\n"

voidprint_tab（）

\t"

voidprint_menu_item（char*item,char*desc）

print_str（item）;

print_str（desc）;

voidprint_str（char*str）

while（*str）

%c"

*str++）;

voidprint_info（char*str,boolenter）

print_str（str）;

if（enter）

ELEMTYPEget_input（）

ELEMTYPEresult;

向栈中放入一个元素:

scanf（SCANF_ITEM,&

result）;

LINKSTACK*stack_push（LINKSTACK*top）

ELEMTYPEdata=get_input（）;

top=PUSH（top,data）;

添加成功！

LINKSTACK*stack_pop（LINKSTACK*top）

top=POP（top）;

删除元素."

LINKSTACK*stack_get_top（LINKSTACK*top）

ELEMTYPEresult=GETTOP（top）;

if（result!

=STACK_NULL）

栈顶元素为"

printf（PRINT_ITEM,result）;

error:

此栈是空栈."

LINKSTACK*stack_empty（LINKSTACK*top）

boolresult=EMPTY（top）;

result）

此栈不为空."

LINKSTACK*stack_cur_size（LINKSTACK*top）

intresult=CURRENT_SIZE（top）;

栈中元素个数为%d"

result）;

LINKSTACK*stack_clear（LINKSTACK*top）

清空成功."

LINKSTACK*link_stack_method（LINKSTACK*top,LINKSTACK*（*fun）（LINKSTACK*src_top））

return（*fun）（top）;

#include<

iostream>

usingnamespacestd;

#defineMAXQSIZE100

typedefstruct

int*base;

intfront;

intrear;

}SqQueue;

SqQueueQ;

voidInitQueue（SqQueue&

Q）

Q.base=（int*）malloc（MAXQSIZE*sizeof（int））;

Q.base）cout<

<

初始化失败！

endl;

else{Q.front=Q.rear=0;

cout<

初始化成功！

voidPrintQueue（SqQueueQ）

while（Q.front!

=Q.rear）

{

cout<

Q.base[Q.front]<

"

;

Q.front=（Q.front+1）%MAXQSIZE;

cout<

intQueueLength（SqQueueQ）

return（Q.rear-Q.front+MAXQSIZE）%MAXQSIZE;

voidEnQueue（SqQueue&

Q,inte）

if（（Q.rear+1）%MAXQSIZE==Q.front）cout<

操作失败!

!

Q.base[Q.rear]=e;

Q.rear=（Q.rear+1）%MAXQSIZE;

voidDeQueue（SqQueue&

Q,int&

e）

if（Q.rear==Q.front）cout<

e=Q.base[Q.front];

Q.front=（Q.front+1）%MAXQSIZE;

删除后循环队列为:

PrintQueue（Q）;

intQueueEmpty（SqQueueQ）

if（Q.front==Q.rear）{cout<

循环队列为空"

return0;

else{cout<

循环队列不为空"

return1;

intGetHead（SqQueueQ）

inte;

if（Q.front==Q.rear）return0;

else{e=Q.base[Q.front];

returne;

voidClearQueue（SqQueue&

while（Q.rear!

=Q.front）Q.front=（Q.front+1）%MAXQSIZE;

voidDestroyQueue（SqQueueQ）

free（Q.base）;

循环队列已清除!

intmain（）

----**********循环队列程序**********----"

0、队列的清除"

1、队列初始化"

2、队列的插入"

3、输出队列"

4、删除元素"

5、判断是否为空"

6、求队列的长度"

7、返回队列的队头元素"

8、退出程序"

SqQueueQ;

intn,k;

for（n=0;

n<

100;

n++）

请选择0-8:

cin>

>

k;

if（k==0）{DestroyQueue（Q）;

n=100;

if（k==1）InitQueue（Q）;

if（k==3）PrintQueue（Q）;

if（k==2）

inte;

输入插入的元素:

cin>

e;

EnQueue（Q,e）;

插入后队列为:

if（k==4）

intdel;

DeQueue（Q,del）;

if（k==5）QueueEmpty（Q）;

if（k==6）cout<

队列的长度为:

QueueLength（Q）<

if（k==7）cout<

队头元素为:

GetHead（Q）<

if（k==8）break;

cmath>

cstdlib>

#defineMAX1000

structsave1

{floatn[MAX];

inttop;

}stack1;

structsave2

{charn[MAX];

}stack2;

//stack1存储数字，stack2存储运算符号.

boolstackempty（save1s）

{if（s.top==-1）return1;

elsereturn0;

boolstackempty2（save2s）

voidpush（save1&

s,floate）//将e入栈

{if（s.top==MAX-1）

{cout<

栈已满"

return;

s.top++;

s.n[s.top]=e;

voidpush2（save2&

s,chare）//将e入栈

voidpop（save1&

s,float&

e）//将栈顶元素出栈，存到e中

{if（s.top==-1）

栈为空"

else{e=s.n[s.top];

s.top--;

}}

voidpop2（save2&

s,char&

{if（s.top==-1）{cout<

s.top--;

intin（chare）//e在栈内的优先级别

{if（e=='

-'

||e=='

+'

）return2;

if（e=='

*'

/'

）return4;

^'

）return5;

（'

）return0;

）'

）return7;

return-1;

intout（chare）//e在栈外的优先级别

）return1;

）return3;

）return6;

voidcount

（floata,charope,floatb）//进行计算并将计算结果入栈

{floatsum;

if（ope=='

）sum=a+b;

）sum=a-b;

）sum=a*b;

）sum=a/b;

）sum=pow（a,b）;

push（stack1,sum）;

intmain（）

{inti=0,len,j,nofpoint,g=0;

//len表示输入式子的长度。

g表示读入的字符是否是字母变量、数字以及运算符。

floata,b;

//a、b用来存储操作数栈中弹出的操作数，便于代入函数中进行计算。

charline[MAX],operate,temp[20];

请输入表达式"

cin>

line;

len=strlen（line）;

stack1.top=-1;

//将栈置为空

stack2.top=-1;

//将栈置为空

while

（1）{g=0;

if（isdigit（line[i]））//若读入的字符为数字，则继续判断下一个字符，直到下一个字符不是数字或者不是小数点，即可保证该操作数是完整的小数，然后将该数入操作数栈。

{j=0;

g=1;

nofpoint=0;

//记录所存