数据结构 顺序栈 链栈 循环队列 链队列 hrbedu文档格式.docx
《数据结构 顺序栈 链栈 循环队列 链队列 hrbedu文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构 顺序栈 链栈 循环队列 链队列 hrbedu文档格式.docx（39页珍藏版）》请在冰豆网上搜索。
对于每一个节点都有data和next域来存储数据和指向下一个节点，所以进行这种节点定义。
typedefstructQNode
{intdata;
QNode*next;
}QNode,*QPtr;
typedefstructQlink
{QPtrfront;
QPtrrear;
}Qlink;
3.算法设计
系统规定的功能设计的算法有：
置空栈、判栈空、进栈、出栈、读栈顶、输出栈、判栈满
1）初始化和建立顺序栈
S1:
定义数据结构类型
char*base;
char*top;
intstacksize;
}Sq//定义结构体，其中包含栈顶、栈尾指针和存储空间
S2：
初始化这个顺序栈
intInitSq（Sq&
S）{
S.base=（char*）malloc（STACK_INIT_SIZE*sizeof（Sq））;
if（!
S.base）exit（OVERFLOW）;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
}//申请存储空间，并且将栈顶栈尾元素指在一个位置，构造空栈
S3：
从键盘输入一串字符，根据这些字符构造顺序栈
Sqcreate（Sq&
InitSq（S）;
printf（"
请输入你的栈"
）;
charstr[100];
gets（str）;
//得到字符
intn=strlen（str）;
for（inti=0;
i<
n;
i++）{
Push（S,str[i]）;
}//调用Push函数将每个字符入栈
returnS;
}
2）置空栈
编写子函数Clear，使其可以实现置空栈功能
intClear（Sq&
while（S.top!
=S.base）{
chare;
Pop（S,e）;
}
returnOK;
}
在主函数里调用Clear子函数，就能达到置空栈的功能
3）判栈空
S1：
编写判断栈空的子函数Empty，使其实现判栈空功能
intEmpty（SqS）{
if（S.top==S.base）
elsereturnERROR;
在主函数调用时根据子函数返回值判断输出内容
if（Empty（S））printf（"
Empty\n"
elseprintf（"
NotEmpty"
4）进栈
从客户端得到所要入栈的元素
printf（"
进栈元素是:
"
scanf（"
%c"
&
x）;
编写子函数Push，使其可以实现将元素入栈功能
intPush（Sq&
S,chare）{
if（S.top-S.base>
=S.stacksize）{
S.base=（char*）realloc（S.base,（S.stacksize+STACKINCREMENT）*sizeof（char））;
S.base）exit（OVERFLOW）;
S.top=S.base+S.stacksize;
//调整指针
S.stacksize+=STACKINCREMENT;
//增大空间
*S.top++=e;
5）出栈
编写子函数GetTop，使其可以得到栈顶元素，从而确定要删去的元素是什么，并且返回这个元素
intGetTop（SqS,char&
e）{
if（S.top==S.base）returnERROR;
e=*（S.top-1）;
returne;
编写子函数Pop，删除栈顶元素
intPop（Sq&
if（S.top==S.base）returnERROR;
e=*--S.top;
编写子函数Print，让这个函数可以输出栈里每一个元素来输出出栈后的栈里元素
intPrint（SqS）{
char*p,*q;
p=S.top;
q=S.base;
if（p==q）returnERROR;
while（p!
=q）
{
printf（"
%c\n"
*（p-1））;
p--;
6）读栈顶
调用函数GetTop，读到栈顶元素，并且输出这个元素
GetTop（S,a）;
a）
7）输出栈
调用函数Print，输出栈里每一个元素
8）判栈满
编写函数T，使其可以实现判栈满功能
intT（SqS）
{
=S.stacksize）
else
returnERROR;
根据返回值，确定输出内容
if（T（S））printf（"
Y\n"
N\n"
9）选择功能
弹出提示，得到键盘处根据提示所输入的字符
选择你想要的功能\n"
1置空栈\n2判断栈空\n3进栈\n4出栈\n5读栈顶\n6输出栈\n7判栈满\n"
%d"
m）;
用switch分析得到的m，根据不同的m进入不同的case，调用不同的函数
switch（m）
{
case1:
Clear（S）;
break;
case2:
if（Empty（S））
printf（"
elseprintf（"
break;
case3:
Push（S,x）;
Print（S）;
case4:
Pop（S,a）;
case5:
a）;
case6:
case7:
}
置空栈、判栈空、进栈、出栈、读栈顶
1）定义节点，初始化链栈，创建链栈
定义节点
structnode*next;
//节点的定义
S2:
初始化链栈
intInit（node*&
h）
{h->
next=NULL;
}//建立一个空栈
编写子函数Set，使其根据键盘端的输入，创建链栈
intSet（node*&
{inti;
charstr[100];
gets（str）;
//得到字符串
intn=strlen（str）;
for（i=0;
i++）Push（h,str[i]）;
//将每一个字符入栈
2）置空栈
intClear（node*&
在主函数里调用Clear子函数，就能达到置空栈的功能
intEmpty（node*&
{if（h->
next==NULL）
elsereturnFALSE;
if（Empty（h））printf（"
intPush（node*&
h,charx）
{node*s;
s=（node*）malloc（sizeof（node））;
s->
data=x;
next=h;
h=s;
intPop（node*&
{charx;
x=h->
data;
node*p;
p=（node*）malloc（sizeof（node））;
p=h;
h=h->
next;
free（p）;
编写子函数Gethead，使其可以得到栈顶元素，从而得到新的栈顶元素来确认成功
intGethead（node*&
h,chara）
next==NULL）returnFALSE;
a=h->
head:
调用Gethead函数即可完成功能
7）选择需要的功能
scanf（"
getchar（）;
switch（m）
{case1:
Clear（h）;
case2:
elseprintf（"
case3:
scanf（"
Push（h,x）;
case4:
Pop（h）;
Gethead（h,a）;
case5:
}
置空队、判队空、进队、出队、读队头元素、输出
1）初始化和建立队列
定义结构体
intfront;
intrear;
初始化队列
intInit（SqQueue&
Q）
{
Q.base=（int*）malloc（MAXQSIZE*sizeof（int））;
if（!
Q.base）return（OVERFLOW）;
Q.front=Q.rear=0;
建立循环队列
intSet（SqQueue&
Init（Q）;
请输入队列:
\n"
i++）En（Q,str[i]）;
2）置空队
编写子函数Clear，使其可以实现置空队功能
intClear（SqQueue&
if（Q.rear==Q.front）returnOK;
Q.rear=Q.front;
在主函数里调用Clear子函数，就能达到置空队的功能
3）判队空
编写判断栈空的子函数Empty，使其实现判队空功能
intEmpty（SqQueue&
在主函数调用时根据队中指针位置判断输出内容
if（Q.front==Q.rear）printf（"
empty"
elseprintf（"
notempty"
4）进队
从客户端得到所要入队的元素
进队元素是:
编写子函数En，使其可以实现将元素入栈功能
intEn（SqQueue&
Q,chare）
if（（Q.rear+1）%MAXQSIZE==Q.front）returnERROR;
Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAXQSIZE;
5）出队
编写子函数De，删除队头元素
编写子函数Gethead，使其可以得到队头元素，从而得到新的队头元素来确认成功
6）读队头元素
调用Gethead函数即可实现
7）输出队中元素
编写子函数Print，使其可以输出队中每一个元素
intPrint（SqQueueQ）
if（Q.rear==Q.front）returnERROR;
inta,b;
a=Q.front;
b=Q.rear;
while（a!
=b）
（printf（"
Q.base[a]））;
a=（a+1）%MAXQSIZE;
8）选择需要的功能
选择你需要的功能\n"
1置空队\n2判队空\n3进队\n4出队\n5读队头元素\n6输出循环队列\n"
while
（1）{printf（"
switch（m）{
case1:
Clear（Q）;
elseprintf（"
break;
你要入队的元素\n"
getchar（）;
En（Q,x）;
if（!
Empty（Q））{De（Q,e）;
Gethead（Q,a）;
printf（"
新队列头元素:
}
elseprintf（"
队列已空"
break;
Gethead（Q,a）;
case6:
Print（Q）;
置空队、判队空、进队、出队、读队头元素
typedefstructQNode
QNode*next;
QPtrfront;
QPtrrear;
//定义单链队列的链式存储结构
初始化
intInitqueue（Qlink&
{Q.front=Q.rear=（QPtr）malloc（sizeof（QNode））;
Q.front）exit（OVERFLOW）;
Q.front->
}//构造空队列
建立队列
QlinkSetqueue（Qlink&
inti;
Initqueue（Q）;
QPtrp;
请输入你的队列"
i++）
{p=（QPtr）malloc（sizeof（QNode））;
p->
data=str[i];
Q.rear->
next=p;
Q.rear=p;
returnQ;
intClear（Qlink&
{Q.front=Q.rear;
intEmpty（Qlink&
if（Q.front==Q.rear）
returnTRUE;
returnFALSE;
入队元素是:
intEn（Qlink&
p=（QPtr）malloc（sizeof（QNode））;
p）exit（OVERFLOW）;
data=e;
intDe（Qlink&
Q,char&
e）
if（Q.front==Q.rear）returnFALSE;
p=Q.front->
next=p->
e=p->
intGethead（QlinkQ,char&
n）
n=Q.front->
next->
调用函数Gethead就可以达到功能
7）功能选择
1置空队\n2判队空\n3进队\n4出队\n5读队头元素\n"
升级会员 