堆栈和队列基本函数.docx
《堆栈和队列基本函数.docx》由会员分享，可在线阅读，更多相关《堆栈和队列基本函数.docx（22页珍藏版）》请在冰豆网上搜索。
堆栈和队列基本函数
一.顺序栈
1.宏定义
#include
#include
#defineMAXSIZE****
#definedatatype****
2.结构体
typedefstruct
{
datatypedata[MAXSIZE];
inttop;
}Seqstack;
3.基本函数
Seqstack*Init_Seqstack（）
/*置空栈函数（初始化）1.先决条件:
无;2.函数作用:
首先建立栈空间,然后初始化栈顶指针,返回栈s的地址*/
{
Seqstack*s;
s=（Seqstack*）malloc（sizeof（Seqstack））;
s->top=-1;
returns;
}
intEmpty_Seqstack（Seqstack*s）
/*判栈空函数1.先决条件:
初始化顺序栈;2.函数作用:
判断栈是否为空,空返回1,不空返回0*/
{
if（s->top==-1）return1;
elsereturn0;
}
intPush_Seqstack（Seqstack*s,datatypex）
/*入栈函数1.先决条件:
初始化顺序栈2.函数作用:
将数据x入栈,栈满则不能,成功返回1,因栈满失败返回0*/
{
if（s->top==MAXSIZE-1）
return0;
s->top=s->top+1;
s->data[s->top]=x;
return1;
}
intPop_Seqstack（Seqstack*s,datatype*x）
/*出栈函数1.先决条件:
初始化顺序栈2.函数作用:
从栈中出一个数据,并将其存放到x中,成功返回1,因栈空失败返回0*/
{
if（s->top==-1）
return0;
*x=s->data[s->top];
s->top--;
return1;
}
intTop_Seqstack（Seqstack*s,datatype*x）
/*取栈顶元素函数1.先决条件:
初始化顺序栈2.函数作用:
取栈顶元素,并把其存放到x中,成功返回1,因栈空失败返回0*/
{
if（s->top==-1）
return0;
*x=s->data[s->top];
return1;
}
intPrintf_Seqstack（Seqstack*s）
/*遍历顺序栈函数1.先决条件:
初始化顺序栈2.函数作用:
遍历顺序栈,成功返回1*/
{
inti,j=0;
for（i=s->top;i>=0;i--）
{
printf（"%d",s->data[i]）;/*因datatype不同而不同*/
j++;
if（j%10==0）
printf（"\n"）;
}
printf（"\n"）;
return1;
}
intConversation_Seqstack（intN,intr）
/*数制转换函数（顺序栈）1.先决条件:
具有置空栈,入栈,出栈函数2.函数作用:
将N转换为r进制的数*/
{
Seqstack*s;
datatypex;
printf（"%d转为%d进制的数为:
",N,r）;/*以后可以删除去*/
s=Init_Seqstack（）;
do
{
Push_Seqstack（s,N%r）;
N=N/r;
}while（N）;
while（Pop_Seqstack（s,&x））
{
if（x>=10）/*为了能转为十进制以上的*/
printf（"%c",x+55）;
else
printf（"%d",x）;
}
free（s）;/*释放顺序栈*/
printf（"\n"）;
return1;
}
4.主函数
intmain（）
{
Seqstack*s;
intchoice;
datatypex;
do{
printf（"****************************************************************\n"）;
printf（"1.置空栈2.判栈空3.入栈4.出栈5.取栈顶元素6.遍历7.退出\n"）;
printf（"****************************************************************\n"）;
printf（"请输入选择（1~7）:
"）;
scanf（"%d",&choice）;
getchar（）;
switch（choice）
{
case1:
s=Init_Seqstack（）;
if（s）
printf（"置空栈成功!
\n"）;break;
case2:
if（Empty_Seqstack（s））
printf（"此为空栈.\n"）;
else
printf（"此不为空栈.\n"）;;break;
case3:
printf（"请输入一个整数:
"）;
scanf（"%d",&x）;
if（Push_Seqstack（s,x））
printf（"入栈成功.\n"）;
else
printf（"栈已满,无法入栈.\n"）;;break;
case4:
if（Pop_Seqstack（s,&x））
printf（"出栈成功,出栈元素为:
%d\n",x）;
else
printf（"出栈失败,因栈为空.\n"）;break;
case5:
if（Top_Seqstack（s,&x））
printf（"取栈顶元素成功,栈顶元素为:
%d\n",x）;
else
printf（"取栈顶元素失败,因栈为空.\n"）;
break;
case6:
Printf_Seqstack（s）;break;
case7:
printf（"谢谢使用!
\n"）;break;
default:
printf（"输入错误，请重新输入!
\n"）;break;
}
}while（choice!
=7）;
return0;
}
二.链栈
1.宏定义
#include
#include
#definedatatype****
2.结构体
typedefstructsnode
{
datatypedata;
structsnode*next;
}Stacknode,*Linkstack;
3.基本函数
LinkstackInit_Linkstack（）
/*初始化栈函数1.先决条件:
无2.函数作用:
初始化链栈,返回top地址*/
{
Linkstacktop;
top=（Linkstack）malloc（sizeof（Stacknode））;
top->next=NULL;
returntop;
}
intEmpty_Linkstack（Linkstacktop）
/*判栈空函数1.先决条件:
初始化链栈2.函数作用:
判断栈是否为空,空返回1,不空返回0*/
{
if（top->next==NULL）
return1;
elsereturn0;
}
intPush_Linkstack（Linkstacktop,datatypex）
/*入栈函数1.先决条件:
初始化链栈2.函数作用:
将数据x入栈,成功返回1,失败返回0*/
{
Stacknode*p;
p=（Stacknode*）malloc（sizeof（Stacknode））;
p->data=x;
p->next=top->next;
top->next=p;
return1;
}
intPop_Linkstack（Linkstacktop,datatype*x）
/*出栈函数1.先决条件:
初始化链栈2.函数作用:
若栈空退出,若没空则将数据出栈,并将其存放到x中,成功返回1,因栈空失败返回0*/
{
if（top->next==NULL）
return0;
Stacknode*p=top->next;
*x=p->data;
top->next=p->next;
free（p）;
return1;
}
intTop_Linkstack（Linkstacktop,datatype*x）
/*取栈顶元素函数1.先决条件:
初始化链栈2.函数作用:
取栈顶元素并放到x中,成功返回1,因栈空失败返回0*/
{
if（top->next==NULL）
return0;
*x=top->next->data;
return1;
}
intPrintf_Linkstack（Linkstacktop）
/*遍历链栈函数1.先决条件:
初始化链栈2.函数作用:
遍历链栈,成功返回1*/
{
Stacknode*p=top->next;
intj=0;
while（p）
{
printf（"%d",p->data）;/*因datatype不同而不同*/
j++;
if（j%10==0）
printf（"\n"）;
p=p->next;
}
printf（"\n"）;
return1;
}
intConversation_Linkstack（intN,intr）
/*数制转换函数（链栈）1.先决条件:
具有置空栈,入栈,出栈函数2.函数作用:
将N转换为r进制的数*/
{
Linkstacktop;
datatypex;
printf（"%d转为%d进制的数为:
",N,r）;/*以后可以删除去*/
top=Init_Linkstack（）;
do
{
Push_Linkstack（top,N%r）;
N=N/r;
}while（N）;
while（Pop_Linkstack（top,&x））
{
if（x>=10）/*为了能转为十进制以上的*/
printf（"%c",x+55）;
else
printf（"%d",x）;
}
printf（"\n"）;
free（top）;/*释放栈顶空间*/
return1;
}
4.主函数
intmain（）
{
Linkstacktop;
intchoice;
datatypex;
do{
printf（"****************************************************************\n"）;
printf（"1.置空栈2.判栈空3.入栈4.出栈5.取栈顶元素6.遍历7.退出\n"）;
printf（"****************************************************************\n"）;
printf（"请输入选择（1~7）:
"）;
scanf（"%d",&choice）;
getchar（）;
switch（choice）
{
case1:
top=Init_Linkstack（）;
if（top）
printf（"置空栈成功!
\n"）;break;
case2:
if（Empty_Linkstack（top））
printf（"此为空栈.\n"）;
else
printf（"此不为空栈.\n"）;;break;
case3:
printf（"请输入一个整数:
"）;
scanf（"%d",&x）;
if（Push_Linkstack（top,x））
printf（"入栈成功.\n"）;
else
printf（"栈已满,无法入栈.\n"）;;break;
case4:
if（Pop_Linkstack（top,&x））
printf（"出栈成功,出栈元素为:
%d\n",x）;
else
printf（"出栈失败,因栈为空.\n"）;break;
case5:
if（Top_Linkstack（top,&x））
printf（"取栈顶元素成功,栈顶元素为:
%d\n",x）;
else
printf（"取栈顶元素失败,因栈为空.\n"）;
break;
case6:
Printf_Linkstack（top）;break;
case7:
printf（"谢谢使用!
\n"）;break;
default:
printf（"输入错误，请重新输入!
\n"）;break;
}
}while（choice!
=7）;
return0;
}
三.顺序队列
1.宏定义
#include
#include
#defineMAXSIZE****
#definedatatype****
2.结构体
typedefstruct
{
datatypedata[MAXSIZE];
intrear,front;
intnum;
}Sequeue;
3.基本函数
Sequeue*Init_Sequeue（）
/*初始化顺序队列函数1.先决条件:
无2.函数作用:
初始化顺序队列,成功返回顺序队列首地址q*/
{
Sequeue*q;
q=（Sequeue*）malloc（sizeof（Sequeue））;
q->front=q->rear=MAXSIZE-1;
q->num=0;
returnq;
}
intIn_Sequeue（Sequeue*q,datatypex）
/*入队函数1.先决条件:
初始化顺序队列2.函数作用:
将数据x入队到q中,成功返回1,因队满失败返回0*/
{
if（q->num==MAXSIZE）
{
printf（"队满.\n"）;/*可视情况删除此句*/
return0;
}
else
{
q->rear=（q->rear+1）%MAXSIZE;
q->data[q->rear]=x;
q->num++;
return1;
}
}
intFront_Sequeue（Sequeue*q,datatype*x）
/*取队头元素函数1.先决条件:
初始化顺序表2.函数作用:
取队头元素并将其存放到x中,成功返回1,因队空而失败返回0*/
{
if（q->num==0）
{
printf（"队空.\n"）;/*可视情况删除此句*/
return0;
}
*x=q->data[q->front+1];
return1;
}
intOut_Sequeue（Sequeue*q,datatype*x）
/*出队函数1.先决条件:
初始化顺序队列2.函数作用:
将数据x入队到q中,成功返回1,因队空失败返回0*/
{
if（q->num==0）
{
printf（"队空.\n"）;/*可视情况删除此句*/
return0;
}
else
{
q->front=（q->front+1）%MAXSIZE;
*x=q->data[q->front];
q->num--;
return1;
}
}
intEmpty_Sequeue（Sequeue*q）
/*判空函数1.先决条件:
初始化顺序队列2.函数作用:
是空返回1,非空返回0*/
{
if（q->num==0）
return1;
elsereturn0;
}
intPrintf_Sequeue（Sequeue*q）
/*遍历函数1.先决条件:
初始化顺序队列2.函数作用:
遍历输出所有数据*/
{
inti,j=q->front+1,n=q->num;
for（i=0;i{
printf（"%d",q->data[j]）;/*因datatype数据不同而不同*/
j++;
j=j%MAXSIZE;
}
printf（"\n"）;
return1;
}
4.主函数
intmain（）
{
Sequeue*q;
intchoice;
datatypex;
do{
printf（"**************************************************************\n"）;
printf（"1.初始化2.判队空3.入队4.出队5.取队头元6.遍历7.退出\n"）;
printf（"**************************************************************\n"）;
printf（"请输入选择（1~7）:
"）;
scanf（"%d",&choice）;
getchar（）;
switch（choice）
{
case1:
q=Init_Sequeue（）;
if（q）
printf（"置空队成功!
\n"）;break;
case2:
if（Empty_Sequeue（q））
printf（"此为空队.\n"）;
else
printf（"此不为空队.\n"）;;break;
case3:
printf（"请输入一个整数:
"）;
scanf（"%d",&x）;
if（In_Sequeue（q,x））
printf（"入队成功.\n"）;
else
printf（"队已满,无法入队.\n"）;;break;
case4:
if（Out_Sequeue（q,&x））
printf（"出队成功,出队元素为:
%d\n",x）;
else
printf（"出队失败,因队为空.\n"）;break;
case5:
if（Front_Sequeue（q,&x））
printf（"取队头元素成功,队头元素为:
%d\n",x）;
else
printf（"取队头元素失败,因队为空.\n"）;
break;
case6:
Printf_Sequeue（q）;break;
case7:
printf（"谢谢使用!
\n"）;break;
default:
printf（"输入错误，请重新输入!
\n"）;break;
}
}while（choice!
=7）;
return0;
}
四.链队列
1.宏定义
#include
#include
#definedatatypeint
2.结构体
typedefstructnode
{
datatypedata;
structnode*next;
}Qnode;
typedefstruct
{
Qnode*front,*rear;
}Lqueue;
3.基本函数
Lqueue*Init_Lqueue（）
/*初始化链队列函数1.先决条件:
无2.函数作用:
初始化链队列,成功返回顺序队列首地址q（头结点）*/
{
Lqueue*q;
Qnode*p;
q=（Lqueue*）malloc（sizeof（Lqueue））;
p=（Qnode*）malloc（sizeof（Qnode））;
p->next=NULL;
q->front=p;
q->rear=p;
returnq;
}
intIn_Lqueue（Lqueue*q,datatypex）
/*入队函数1.先决条件:
初始化链队列2.函数作用:
将数据x入队到q中,成功返回1*/
{
Qnode*p;
p=（Qnode*）malloc（sizeof（Qnode））;
p->data=x;
p->next=NULL;
q->rear->next=p;
q->rear=p;
return1;
}
intEmpty_Lqueue（Lqueue*q）
/*判空函数1.先决条件:
初始化链队列2.函数作用:
是空返回1,非空返回0*/
{
if（q->front==q->rear）
return1;
elsereturn0;
}
intFront_Lqueue（Lqueue*q,datatype*x）
/*取队头元素函数1.先决条件:
初始化链队列2.函数作用:
取队头元素并将其存放到x中,成功返回1,因队空而失败返回0*/
{
if（Empty_Lqueue（q））
{
printf（"队空.\n"）;/*可视情况删除此句*/
return0;
}
*x=q->front->next->data;
return1;
}
intOut_Lqueue（Lqueue*q,datatype*x）
/*出队函数1.先决条件:
初始化链队列2.函数作用:
将数据x入队到q中,成功返回1,因队空失败返回0*/
{
Qnode*p;
if（Empty_Lqueue（q））
{
printf（"队空.\n"）;/*可视情况删除此句*/
return0;
}
p=q->front->next;
*x=p->data;
q->front->next=p->next;
free（p）;
if（q->front->next==NULL）
q->rear=q->front;
return1;
}
intPrintf_Lqueue（Lqueue*q）
/*遍历函数1.先决条件:
初始化链队列2.函数作用:
遍历输出所有数据*/
{
Qnode*p;
for（p=q->front->next;p!
=NULL;p=p->next）
printf（"%d",p->data）;/*因datatype数据不同而不同*/
printf（"\n"）;
return1;
}
4.主函数
intmain（）
{
Lqueue*q;
intchoice;
datatypex;
do{
printf（"**************************************************************\n"）;
printf（"1.初始化2.判队空3.入队4.出队5.取队头元6.遍
升级会员 