实验报告第三章1211102车红岫.docx
《实验报告第三章1211102车红岫.docx》由会员分享，可在线阅读，更多相关《实验报告第三章1211102车红岫.docx（24页珍藏版）》请在冰豆网上搜索。
实验报告第三章1211102车红岫
实验名称：
第3章实验
实验类型：
实验
班级：
学号：
姓名：
车红岫
实验日期：
2013.6.13
1.问题描述
以下验证性实验都做
（1）顺序栈
●顺序栈的C语言描述
●基本运算的算法——置空栈、判栈空、进栈、出栈、读栈顶、输出栈、判栈满
（2）链栈
●链栈的C语言描述
●基本运算的算法——置空栈、判栈空、进栈、出栈、读栈顶
（3）循环队列
●循环队列的C语言描述
●基本运算的算法——置空队、判队空、进队、出队、读队头元素、输出循环队列
（4）链队列
●链队列的C语言描述
●基本运算的算法——置空队、判队空、进队、出队、读队头元素
2.数据结构设计
1）顺序栈
typedefstruct//栈结构声明
{intdata[MAXSIZE];
inttop;
}SqStack;
2）链栈
typedefstructSNode
{
intdata;
structSNode*next;
}SNode,*LinkStack;
3）循环队列
typedefstruct
{
QElemType*base;//初始化的动态分配存储空间
intfront;//头指针,若队列不空,指向队列头元素
intrear;//尾指针,若队列不空,指向队列尾元素的下一个位置
}SqQueue;
4）链队列
typedefstructQNode
{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
3.算法设计
4.界面设计
1）顺序栈
2）链栈
3）循环队列
4）链队列
5.运行、测试
1）顺序栈
（1）运行程序，显示菜单
（2）输入所选操作
（3）输出结果
2）链栈
（1）运行程序，显示菜单
（2）输入所选操作
（3）输出结果
3）循环队列
（1）运行程序，显示菜单
（2）输入n
（3）输出结果
4）链队列
（1）运行程序，显示菜单
（2）输入n
（3）输出结果
6.实验收获及思考
选用合适的数据结构可以简化问题。
附录：
源代码
1）顺序栈
#include
#include
#include
#include
#include
#include
#defineMAXSIZE100
typedefstruct//栈结构声明
{intdata[MAXSIZE];
inttop;
}SqStack;
voidPushStack（SqStack*s,intx）//入栈
{if（s->top==MAXSIZE-1）
printf（"栈已满，不能入栈\n"）;
else
{s->data[++s->top]=x;
printf（"入栈已完成\n"）;
}
}
intEmpty（SqStack*s）//判断栈空
{return（s->top==-1?
1:
0）;
}
intPop（SqStack*s,intx）//删除栈顶元素，并用x返回其值
{if（Empty（s））
{printf（"空栈\n"）;
return0;
}
s->top--;
printf（"出栈成功\n"）;
return1;
}
voidprintstruct（SqStack*s,intx）//输出栈
{if（Empty（s））
{printf（"栈空\n"）;
exit（0）;
}
else
{x=s->data[s->top];
printf（"%d",x）;//打印
s->top--;//修改栈顶指针
}
}
intGetStackTop（SqStacks）//取栈顶
{returns.data[s.top];
}
intmain（）
{intx;
SqStacknewStack;
newStack.top=-1;
printf（"1置空栈\n"）;
printf（"2进栈\n"）;
printf（"3出栈\n"）;
printf（"4取栈顶元素\n"）;
printf（"5显示栈内元素\n"）;
printf（"6判断栈空\n"）;
printf（"0退出\n"）;
while
（1）
{switch（getch（））
{case'1':
newStack.top=-1;
printf（"空栈\n"）;
break;
case'2':
printf（"请输入要进栈的元素\n"）;
scanf（"%d",&x）;
PushStack（&newStack,x）;
break;
case'3':
Pop（&newStack,x）;
break;
case'4':
if（Empty（&newStack））
{printf（"空栈\n"）;
}
else
printf（"栈顶元素是%d\n",GetStackTop（newStack））;
break;
case'5':
if（Empty（&newStack））
{printf（"空栈\n"）;
}
else
printstruct（&newStack,x）;
break;
case'6':
if（Empty（&newStack））
{printf（"空栈\n"）;
}
else
printf（"非空\n"）;
break;
case'0':
exit（0）;
break;
default:
printf（"操作出错,请重新输入!
\n"）;
break;
}
}return0;
}
2）链栈
#include
#include
typedefstructSNode
{
intdata;
structSNode*next;
}SNode,*LinkStack;
LinkStacktop;
LinkStackPushStack（LinkStacktop,intx）//入栈
{
LinkStacks;
s=（LinkStack）malloc（sizeof（SNode））;
s->data=x;
s->next=top;
top=s;
returntop;
}
LinkStackPopStack（LinkStacktop）//退栈
{
LinkStackp;
if（top!
=NULL）
{
p=top;
top=top->next;
free（p）;
printf（"退栈已完成\n"）;
returntop;
}
else
printf（"栈是空的，无法退栈！
\n"）;
return0;
}
intGetStackTop（LinkStacktop）//取栈顶元素
{
returntop->data;
}
boolIsEmpty（）//bool取值false和true，是0和1的区别,bool只有一个字节,BOOL为int型,bool为布尔型
{
returntop==NULL?
true:
false;
}
intPrint（）//输出栈
{
SNode*p;
p=top;
if（IsEmpty（））
{
printf（"空栈!
\n"）;
return0;
}
while（p）
{
printf（"%d",p->data）;
p=p->next;
}
printf（"\n"）;
return1;
}
voidmain（）
{
intx,a,b;
charm;
do
{
printf（"\n"）;
printf（"1.置空栈\n"）;
printf（"2.进栈\n"）;
printf（"3.退栈\n"）;
printf（"4.取栈顶元素\n"）;
printf（"5.退出程序\n"）;
printf（"\n请选择一个操作:
"）;
scanf（"%c",&m）;
switch（m）
{
case'1':
top=NULL;
printf（"\n栈已置空!
"）;
break;
case'2':
printf（"\n请输入要进栈的元素个数是:
"）;
scanf（"%d",&a）;
printf（"\n请输入要进栈的%d个元素:
",a）;
for（b=0;b{
scanf（"%d",&x）;
top=PushStack（top,x）;
}
printf（"进栈已完成！
\n"）;
printf（"\n输出栈为:
"）;
Print（）;
break;
case'3':
printf（"\n操作之前的输出栈为:
"）;
Print（）;
top=PopStack（top）;
printf（"\n操作过后的输出栈为:
"）;
Print（）;
break;
case'4':
printf（"\n输出栈为:
"）;
Print（）;
if（top!
=NULL）
printf（"\n栈顶元素是：
%d\n",GetStackTop（top））;
else
printf（"\n栈是空的，没有元素！
"）;
break;
case'5':
break;
default:
printf（"\n输入的操作不对，请重新输入!
"）;
break;
}
getchar（）;
}
while（m!
='5'）;
}
3）循环队列
#include
#include
#defineOK1
#defineERROR0
typedefintStatus;//Status是函数的类型,其值是函数结果状态代码，如OK等
typedefintQElemType;
#defineMAXQSIZE100//最大队列长度（对于循环队列，最大队列长度要减1）
typedefstruct
{
QElemType*base;//初始化的动态分配存储空间
intfront;//头指针,若队列不空,指向队列头元素
intrear;//尾指针,若队列不空,指向队列尾元素的下一个位置
}SqQueue;
StatusInitQueue（SqQueue&Q）//构造一个空队列Q，该队列预定义大小为MAXQSIZE
//请补全代码
{Q.base=（QElemType*）malloc（MAXQSIZE*sizeof（QElemType））;
if（!
Q.base）returnERROR;
Q.front=Q.rear=0;
returnOK;
}
StatusEnQueue（SqQueue&Q,QElemTypee）//插入元素e为Q的新的队尾元素
{if（（Q.rear+1）%MAXQSIZE==Q.front）returnERROR;
Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAXQSIZE;
returnOK;
}
StatusDeQueue（SqQueue&Q,QElemType&e）//若队列不空,则删除Q的队头元素,用e返回其值,并返回OK;否则返回ERROR
{if（Q.front==Q.rear）returnERROR;
e=Q.base[Q.front];
Q.front=（Q.front+1）%MAXQSIZE;
returnOK;
}
StatusGetHead（SqQueueQ,QElemType&e）//若队列不空，则用e返回队头元素，并返回OK，否则返回ERROR
{if（Q.front==Q.rear）returnERROR;
e=Q.base[Q.front];
returnOK;
}
StatusQueueTraverse（SqQueueQ）//若队列不空，则从队头到队尾依次输出各个队列元素，并返回OK；否则返回ERROR.
{inti;
i=Q.front;
if（Q.front==Q.rear）printf（"空队列!
"）;
else{
printf（"队列为:
"）;
while（i{
printf（"%d",Q.base[i]）;
i=i+1;
}
}
printf（"\n"）;
returnOK;
}
intmain（）
{
inta;
SqQueueS;
QElemTypex,e;
if（InitQueue（S））//判断顺序表是否创建成功
{
printf（"队列已建立.\n"）;
}
while
（1）
{
printf（"1:
输入\n2:
删除\n3:
读队列元素\n4:
输出队列\n0:
退出\n请选择:
\n"）;
scanf（"%d",&a）;
switch（a）
{
case1:
scanf（"%d",&x）;
if（!
EnQueue（S,x））printf（"错误!
\n"）;//判断入队是否合法
elseprintf（"数据%d输入成功!
\n",x）;
break;
case2:
if（!
DeQueue（S,e））printf（"错误!
\n"）;//判断出队是否合法
elseprintf（"数据%d删除成功!
\n",e）;
break;
case3:
if（!
GetHead（S,e））printf（"错误!
\n"）;//判断GetHead是否合法
elseprintf（"队列头元素为%d!
\n",e）;
break;
case4:
QueueTraverse（S）;
break;
case0:
return1;
}
}
}
4）链队列
#defineNULL0
#include
#include
typedefintQElemType;
typedefstructQNode
{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct
{
QueuePtrfront;
QueuePtrrear;
}LinkQueue;
intInitQueue（LinkQueue&Q）//初始化队列
{
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
Q.front）
return0;
Q.front->next=NULL;
return1;
}
intQueueEmpty（LinkQueueQ）//判断队列空
{
if（Q.front==Q.rear）return1;
return0;
}
intDestroyQueue（LinkQueue&Q）
{
while（Q.front）
{
Q.rear=Q.front->next;
free（Q.front）;
Q.front=Q.rear;
}
return1;
}
intEnQueue（LinkQueue&Q,QElemTypee）//入队列
{
QNode*p;
p=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）
return0;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return1;
}
intDeQueue（LinkQueue&Q,QElemType&e）//出队列
{
QNode*p;
if（QueueEmpty（Q））
return0;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if（Q.rear==p）
Q.rear=Q.front;
free（p）;
return1;
}
intGetHead（LinkQueueQ,QElemType&e）//去队列头元素
{
if（QueueEmpty（Q））
return0;
else
e=Q.front->next->data;
return1;
}
intPrintQueue（LinkQueueQ）//输出队列
{
QNode*p=Q.front->next;
if（Q.front==Q.rear）
{
printf（"空队列\n"）;
return0;
}
else
{
printf（"输出链队列：
\n"）;
while（Q.front）
{
printf（"%d",p->data）;
if（p==Q.rear）
break;
p=p->next;
}
printf（"\n"）;
}
return1;
}
voidmain（）
{
intn;
QElemTypee=1;
inti;
LinkQueueQ;
InitQueue（Q）;
printf（"请输入队列的初始数据（按0结束）：
\n"）;
while（e）
{
scanf（"%d",&e）;
if（!
e）break;
EnQueue（Q,e）;
}
for（i=0;i<20;i++）
{
printf（"请输入以下数字执行相应程序:
\n"）;
printf（"1:
元素进链队列\n"）;
printf（"2:
输出队头元素\n"）;
printf（"3:
出队列\n"）;
printf（"4:
输出链队列\n"）;
printf（"5:
判队列空\n"）;
printf（"6:
置空队列\n"）;
printf（"0:
结束程序\n"）;
scanf（"%d",&n）;
switch（n）
{
case1:
printf（"请输入要的进链队列的数（用空格隔开）：
\n"）;
scanf（"%d",&e）;
EnQueue（Q,e）;
break;
case2:
printf（"队头元素为：
\n"）;
GetHead（Q,e）;
printf（"%d\n",e）;
break;
case3:
printf（"出队列：
\n"）;
DeQueue（Q,e）;
printf（"%d\n",e）;
break;
case4:
PrintQueue（Q）;
break;
case5:
if（Q.front==Q.rear）
printf（"空队列"）;
else
printf（"非空队列"）;
break;
case6:
Q.front=Q.rear;
printf（"已置空"）;
break;
case0:
break;
default:
printf（"输入错误！
\n"）;
break;
}
}
}
升级会员 