数据结构栈与队列完整程序一定能运行.docx
《数据结构栈与队列完整程序一定能运行.docx》由会员分享，可在线阅读，更多相关《数据结构栈与队列完整程序一定能运行.docx（21页珍藏版）》请在冰豆网上搜索。
数据结构栈与队列完整程序一定能运行
顺序栈
#include"stdio.h"
#include"stdlib.h"
#include"io.h"
#include"math.h"
#include"time.h"
#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0
#defineMAXSIZE20/*存储空间初始分配量*/
typedefintStatus;
typedefintSElemType;/*SElemType类型根据实际情况而定，这里假设为int*/
/*顺序栈结构*/
typedefstruct
{
SElemTypedata[MAXSIZE];
inttop;/*用于栈顶指针*/
}SqStack;
Statusvisit（SElemTypec）
{
printf（"%d",c）;
returnOK;
}
/* 构造一个空栈S*/
StatusInitStack（SqStack*S）
{
/*S.data=（SElemType*）malloc（MAXSIZE*sizeof（SElemType））;*/
S->top=-1;
returnOK;
}
/*把S置为空栈*/
StatusClearStack（SqStack*S）
{
S->top=-1;
returnOK;
}
/*若栈S为空栈，则返回TRUE，否则返回FALSE*/
StatusStackEmpty（SqStackS）
{
if（S.top==-1）
returnTRUE;
else
returnFALSE;
}
/*返回S的元素个数，即栈的长度*/
intStackLength（SqStackS）
{
returnS.top+1;
}
/*若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR*/
StatusGetTop（SqStackS,SElemType*e）
{
if（S.top==-1）
returnERROR;
else
*e=S.data[S.top];
returnOK;
}
/*插入元素e为新的栈顶元素*/
StatusPush（SqStack*S,SElemTypee）
{
if（S->top==MAXSIZE-1）/*栈满*/
{
returnERROR;
}
S->top++; /*栈顶指针增加一*/
S->data[S->top]=e; /*将新插入元素赋值给栈顶空间*/
returnOK;
}
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
StatusPop（SqStack*S,SElemType*e）
{
if（S->top==-1）
returnERROR;
*e=S->data[S->top]; /*将要删除的栈顶元素赋值给e*/
S->top--; /*栈顶指针减一*/
returnOK;
}
/*从栈底到栈顶依次对栈中每个元素显示*/
StatusStackTraverse（SqStackS）
{
inti;
i=0;
while（i<=S.top）
{
visit（S.data[i++]）;
}
printf（"\n"）;
returnOK;
}
intmain（）
{
intj;
SqStacks;
inte;
if（InitStack（&s）==OK）
for（j=1;j<=10;j++）
Push（&s,j）;
printf（"栈中元素依次为：
"）;
StackTraverse（s）;
Pop（&s,&e）;
printf（"弹出的栈顶元素e=%d\n",e）;
printf（"栈空否：
%d（1:
空0:
否）\n",StackEmpty（s））;
GetTop（s,&e）;
printf（"栈顶元素e=%d栈的长度为%d\n",e,StackLength（s））;
ClearStack（&s）;
printf（"清空栈后，栈空否：
%d（1:
空0:
否）\n",StackEmpty（s））;
return0;
}
两栈共享空间
#include"stdio.h"
#include"stdlib.h"
#include"io.h"
#include"math.h"
#include"time.h"
#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0
#defineMAXSIZE20/*存储空间初始分配量*/
typedefintStatus;
typedefintSElemType;/*SElemType类型根据实际情况而定，这里假设为int*/
/*两栈共享空间结构*/
typedefstruct
{
SElemTypedata[MAXSIZE];
inttop1; /*栈1栈顶指针*/
inttop2; /*栈2栈顶指针*/
}SqDoubleStack;
Statusvisit（SElemTypec）
{
printf（"%d",c）;
returnOK;
}
/* 构造一个空栈S*/
StatusInitStack（SqDoubleStack*S）
{
S->top1=-1;
S->top2=MAXSIZE;
returnOK;
}
/*把S置为空栈*/
StatusClearStack（SqDoubleStack*S）
{
S->top1=-1;
S->top2=MAXSIZE;
returnOK;
}
/*若栈S为空栈，则返回TRUE，否则返回FALSE*/
StatusStackEmpty（SqDoubleStackS）
{
if（S.top1==-1&&S.top2==MAXSIZE）
returnTRUE;
else
returnFALSE;
}
/*返回S的元素个数，即栈的长度*/
intStackLength（SqDoubleStackS）
{
return（S.top1+1）+（MAXSIZE-S.top2）;
}
/*插入元素e为新的栈顶元素*/
StatusPush（SqDoubleStack*S,SElemTypee,intstackNumber）
{
if（S->top1+1==S->top2） /*栈已满，不能再push新元素了*/
returnERROR;
if（stackNumber==1） /*栈1有元素进栈*/
S->data[++S->top1]=e;/*若是栈1则先top1+1后给数组元素赋值。
*/
elseif（stackNumber==2） /*栈2有元素进栈*/
S->data[--S->top2]=e;/*若是栈2则先top2-1后给数组元素赋值。
*/
returnOK;
}
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
StatusPop（SqDoubleStack*S,SElemType*e,intstackNumber）
{
if（stackNumber==1）
{
if（S->top1==-1）
returnERROR;/*说明栈1已经是空栈，溢出*/
*e=S->data[S->top1--];/*将栈1的栈顶元素出栈*/
}
elseif（stackNumber==2）
{
if（S->top2==MAXSIZE）
returnERROR;/*说明栈2已经是空栈，溢出*/
*e=S->data[S->top2++];/*将栈2的栈顶元素出栈*/
}
returnOK;
}
StatusStackTraverse（SqDoubleStackS）
{
inti;
i=0;
while（i<=S.top1）
{
visit（S.data[i++]）;
}
i=S.top2;
while（i {
visit（S.data[i++]）;
}
printf（"\n"）;
returnOK;
}
intmain（）
{
intj;
SqDoubleStacks;
inte;
if（InitStack（&s）==OK）
{
for（j=1;j<=5;j++）
Push（&s,j,1）;
for（j=MAXSIZE;j>=MAXSIZE-2;j--）
Push（&s,j,2）;
}
printf（"栈中元素依次为：
"）;
StackTraverse（s）;
printf（"当前栈中元素有：
%d\n",StackLength（s））;
Pop（&s,&e,2）;
printf（"弹出的栈顶元素e=%d\n",e）;
printf（"栈空否：
%d（1:
空0:
否）\n",StackEmpty（s））;
for（j=6;j<=MAXSIZE-2;j++）
Push（&s,j,1）;
printf（"栈中元素依次为：
"）;
StackTraverse（s）;
printf（"栈满否：
%d（1:
否0:
满）\n",Push（&s,100,1））;
ClearStack（&s）;
printf（"清空栈后，栈空否：
%d（1:
空0:
否）\n",StackEmpty（s））;
return0;
}
链栈
#include"stdio.h"
#include"stdlib.h"
#include"io.h"
#include"math.h"
#include"time.h"
#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0
#defineMAXSIZE20/*存储空间初始分配量*/
typedefintStatus;
typedefintSElemType;/*SElemType类型根据实际情况而定，这里假设为int*/
/*链栈结构*/
typedefstructStackNode
{
SElemTypedata;
structStackNode*next;
}StackNode,*LinkStackPtr;
typedefstruct
{
LinkStackPtrtop;
intcount;
}LinkStack;
Statusvisit（SElemTypec）
{
printf（"%d",c）;
returnOK;
}
/* 构造一个空栈S*/
StatusInitStack（LinkStack*S）
{
S->top=（LinkStackPtr）malloc（sizeof（StackNode））;
if（!
S->top）
returnERROR;
S->top=NULL;
S->count=0;
returnOK;
}
/*把S置为空栈*/
StatusClearStack（LinkStack*S）
{
LinkStackPtrp,q;
p=S->top;
while（p）
{
q=p;
p=p->next;
free（q）;
}
S->count=0;
returnOK;
}
/*若栈S为空栈，则返回TRUE，否则返回FALSE*/
StatusStackEmpty（LinkStackS）
{
if（S.count==0）
returnTRUE;
else
returnFALSE;
}
/*返回S的元素个数，即栈的长度*/
intStackLength（LinkStackS）
{
returnS.count;
}
/*若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR*/
StatusGetTop（LinkStackS,SElemType*e）
{
if（S.top==NULL）
returnERROR;
else
*e=S.top->data;
returnOK;
}
/*插入元素e为新的栈顶元素*/
StatusPush（LinkStack*S,SElemTypee）
{
LinkStackPtrs=（LinkStackPtr）malloc（sizeof（StackNode））;
s->data=e;
s->next=S->top; /*把当前的栈顶元素赋值给新结点的直接后继，见图中①*/
S->top=s; /*将新的结点s赋值给栈顶指针，见图中②*/
S->count++;
returnOK;
}
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
StatusPop（LinkStack*S,SElemType*e）
{
LinkStackPtrp;
if（StackEmpty（*S））
returnERROR;
*e=S->top->data;
p=S->top; /*将栈顶结点赋值给p，见图中③*/
S->top=S->top->next; /*使得栈顶指针下移一位，指向后一结点，见图中④*/
free（p）; /*释放结点p*/
S->count--;
returnOK;
}
StatusStackTraverse（LinkStackS）
{
LinkStackPtrp;
p=S.top;
while（p）
{
visit（p->data）;
p=p->next;
}
printf（"\n"）;
returnOK;
}
intmain（）
{
intj;
LinkStacks;
inte;
if（InitStack（&s）==OK）
for（j=1;j<=10;j++）
Push（&s,j）;
printf（"栈中元素依次为：
"）;
StackTraverse（s）;
Pop（&s,&e）;
printf（"弹出的栈顶元素e=%d\n",e）;
printf（"栈空否：
%d（1:
空0:
否）\n",StackEmpty（s））;
GetTop（s,&e）;
printf（"栈顶元素e=%d栈的长度为%d\n",e,StackLength（s））;
ClearStack（&s）;
printf（"清空栈后，栈空否：
%d（1:
空0:
否）\n",StackEmpty（s））;
return0;
}
斐波那契数列、
#include"stdio.h"
intFbi（inti） /*斐波那契的递归函数*/
{
if（i<2）
returni==0?
0:
1;
returnFbi（i-1）+Fbi（i-2）; /*这里Fbi就是函数自己，等于在调用自己*/
}
intmain（）
{
inti;
inta[40];
printf（"迭代显示斐波那契数列：
\n"）;
a[0]=0;
a[1]=1;
printf（"%d",a[0]）;
printf（"%d",a[1]）;
for（i=2;i<40;i++）
{
a[i]=a[i-1]+a[i-2];
printf（"%d",a[i]）;
}
printf（"\n"）;
printf（"递归显示斐波那契数列：
\n"）;
for（i=0;i<40;i++）
printf（"%d",Fbi（i））;
return0;
}
顺序队列
#include"stdio.h"
#include"stdlib.h"
#include"io.h"
#include"math.h"
#include"time.h"
#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0
#defineMAXSIZE20/*存储空间初始分配量*/
typedefintStatus;
typedefintQElemType;/*QElemType类型根据实际情况而定，这里假设为int*/
/*循环队列的顺序存储结构*/
typedefstruct
{
QElemTypedata[MAXSIZE];
intfront; /*头指针*/
intrear; /*尾指针，若队列不空，指向队列尾元素的下一个位置*/
}SqQueue;
Statusvisit（QElemTypec）
{
printf（"%d",c）;
returnOK;
}
/*初始化一个空队列Q*/
StatusInitQueue（SqQueue*Q）
{
Q->front=0;
Q->rear=0;
return OK;
}
/*将Q清为空队列*/
StatusClearQueue（SqQueue*Q）
{
Q->front=Q->rear=0;
returnOK;
}
/*若队列Q为空队列,则返回TRUE,否则返回FALSE*/
StatusQueueEmpty（SqQueueQ）
{
if（Q.front==Q.rear）/*队列空的标志*/
returnTRUE;
else
returnFALSE;
}
升级会员 