实验报告3讲解.docx
《实验报告3讲解.docx》由会员分享，可在线阅读，更多相关《实验报告3讲解.docx（16页珍藏版）》请在冰豆网上搜索。
实验报告3讲解
数据结构
上机实验报告
实验三栈和队列
班级：
13级计本二班
姓名：
杨宴强
学号：
201392130129
实验三栈和队列
一、实验目的：
⒈学习顺序栈的基本操作
2.学习链栈的基本操作
3.学习循环队列基本操作
4.学习链队列基本操作
二、实验内容：
⒈顺序栈的基本运算
2.链栈的基本操作
3.循环队列的基本运算
4.链队列的基本运算
三、实验步骤及结果：
1：
顺序栈
#include"stdio.h"
#include"stdlib.h"
#defineMAXSIZE20
typedefstruct
{
chardata[MAXSIZE];//栈中元素存储空间
inttop;//栈顶指针
}SeqStack;//顺序栈类型
voidInit_SeqStack（SeqStack**s）//顺序栈初始化
{
*s=（SeqStack*）malloc（sizeof（SeqStack））;//在主函数中申请栈空间
（*s）->top=-1;//置栈空标志
}
intEmpty_SeqStack（SeqStack*s）//判断栈是否为空
{
if（s->top==-1）//栈为空时
return1;//返回1
else
return0;//返回0
}
voidPush_SeqStack（SeqStack*s,charx）//顺序栈入栈
{
if（s->top==MAXSIZE-1）//判断是否栈满
printf（"Stackisfull!
\n"）;//栈已满
else
{
s->top++;//s指向下个节点
s->data[s->top]=x;//元素x压入栈*s中
}
}
voidPop_SeqStack（SeqStack*s,char*x）//将栈*s中的栈顶元素出栈并通过参数x返回给主调函数
{
if（s->top==-1）//栈空返回1
printf（"Stackisempty!
\n"）;//栈为空
else
{
*x=s->data[s->top];//栈顶元素出栈
s->top--;//栈顶指针top-1
}
}
voidTop_SeqStack（SeqStack*s,char*x）//取顺序栈栈顶元素
{
if（s->top==-1）//栈空返回1
printf（"Stackisempty!
\n"）;//栈为空
else
{
*x=s->data[s->top];//取栈顶元素值
}
}
voidprint（SeqStack*s）//顺序栈输出
{
inti;//定义变量i
for（i=0;i<=s->top;i++）//判断
printf（"%4d",s->data[i]）;//读入数据
printf（"\n"）;//输出栈
}
voidmain（）
{
SeqStack*s;//定义指针s
charx,*y=&x;//y是指向x的指针，出栈元素经过y传给变量x
Init_SeqStack（&s）;//顺序栈初始化
if（Empty_SeqStack（s））//判断栈是否为空
printf（"Stackisempty!
\n"）;
printf（"Inputdataofstack:
\n"）;//顺序栈元素入栈
scanf（"%c",&x）;//读入数据
while（x!
='\n'）//对x的计数直到\n结束
{
Push_SeqStack（s,x）;//x入栈
scanf（"%c",&x）;
}
printf（"Outputalldataofstack:
\n"）;//提示
print（s）;//输出顺序栈中的元素
Pop_SeqStack（s,y）;//顺序栈元素出栈
printf（"OutputdataofPopstack:
%c\n",*y）;//输出出栈元素
printf（"Outputalldataofstack:
\n"）;
print（s）;//输出出栈后顺序栈中的元素
Top_SeqStack（s,y）;//读取顺序栈栈顶元素
printf（"Outputdataoftopstack:
%c\n",*y）;//输出读出的栈顶元素
printf（"Outputalldataofstack:
\n"）;
print（s）;//输出当前的顺序栈中的元素
}
2链栈
#include
#include
typedefstructnode
{
chardata;
structnode*next;
}StackNode;//链栈元素类型
voidInit_LinkStack（StackNode**s）//链栈初始化
{
*s=NULL;
}
intEmpty_LinkStack（StackNode*s）//判断链栈是否为空
{
if（s==NULL）
return1;
else
return0;
}
voidPush_LinkStack（StackNode**top,charx）//链栈元素入栈
{
StackNode*p;
p=（StackNode*）malloc（sizeof（StackNode））;//生成存储空间
p->data=x;
p->next=*top;//新生成的栈顶元素*p其后继为原栈顶元素**top
*top=p;//栈顶指针*top指向新的栈顶元素*p
}
voidPop_LinkStack（StackNode**top,char*x）//链栈元素出栈
{
StackNode*p;
if（*top==NULL）
printf（"Stackisempty!
\n"）;//栈空
else
{
*x=（*top）->data;//栈顶元素经指针x传给对应的变量
p=*top;
*top=（*top）->next;
free（p）;
}
}
voidprint（StackNode*p）//链栈输出
{
while（p!
=NULL）
{
printf（"%c,",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidmain（）
{
StackNode*s;
charx,*y=&x;//出栈元素经指针y传给x
Init_LinkStack（&s）;//链栈初始化
if（Empty_LinkStack（s））//判断链栈是否为空
printf（"Stackisempty!
\n"）;
printf（"Inputanystring:
\n"）;//链栈元素入栈
scanf（"%c",&x）;
while（x!
='\n'）
{
Push_LinkStack（&s,x）;
scanf（"%c",&x）;
}
printf（"Outputstring:
\n"）;//链栈输出
print（s）;
printf（"Outputstack:
\n"）;
Pop_LinkStack（&s,y）;//链栈元素出栈
printf（"ElementofOutputstackis%c\n",*y）;//输出出栈元素
printf（"Outputstring:
\n"）;
print（s）;//链栈输出
}
3循环队列
#include"stdio.h"
#include"stdlib.h"
#defineMAXSIZE20
typedefstruct
{
chardata[MAXSIZE];//队头元素存储空间
intrear,front;//队尾和队头指针
}SeQueue;//顺序队列类型
voidInt_SeQueue（SeQueue**q）//置空队
{
*q=（SeQueue*）malloc（sizeof（SeQueue））;//生成循环队列的存储空间
（*q）->front=0;//队尾与队头指针相等则为队空
（*q）->rear=0;
}
intEmpty_SeQueue（SeQueue*q）//判队空
{
if（q->front==q->rear）//判断是否队空
return1;//队空
else
return0;//队不空
}
voidIn_SeQueue（SeQueue*q,charx）//元素入队
{
if（（q->rear+1）%MAXSIZE==q->front）//判断是否队满
printf（"Queueisfull!
\n"）;//队满，入队失败
else
{
q->rear=（q->rear+1）%MAXSIZE;//队尾指针加1
q->data[q->rear]=x;//将元素X入队
}
}
voidOut_SeQueue（SeQueue*q,char*x）//元素出队
{
if（q->front==q->rear）//判断是否队空
printf（"Queueisempty"）;//队空，出队失败
else
{
q->front=（q->front+1）%MAXSIZE;//队头指针加1
*x=q->data[q->front];//队头元素出对并由x返回队头元素值
}
}
voidprint（SeQueue*q）//循环队列输出
{
inti;//定义变量i
i=（q->front+1）%MAXSIZE;//i入队
while（i!
=q->rear）//判断队空
{
printf（"%4c\n",q->data[i]）;//读入数据信息
i=（i+1）%MAXSIZE;//逐步累加
}
printf（"%4c\n",q->data[i]）;//输出
}
voidmain（）
{
SeQueue*q;//定义指针q
charx,*y=&x;//出对元素经指针y传给x
Int_SeQueue（&q）;//循环队列初始化
if（Empty_SeQueue（q））//判队空
printf（"Queueisempty!
\n"）;//提示
printf（"Inputanystring:
\n"）;//给循环队列输入元素
scanf（"%c",&x）;
while（x!
='\n'）
{
In_SeQueue（q,x）;//元素入队
scanf（"%c",&x）;
}
printf（"OutputelementsofQueue:
\n"）;
print（q）;//循环队列输出
printf（"OutputQueue:
\n"）;
Out_SeQueue（q,y）;//循环队列元素出队
printf（"ElementofOutputQueueis%c\n",*y）;//输出出队元素
printf（"OutputelementsofQueue:
\n"）;
print（q）;//输出出队后的循环队列元素
}
4.链队列
#include"stdio.h"
#include"stdlib.h"
#defineMAXSIZE30
typedefstructnode
{
chardata;
structnode*next;
}QNode;//链队列结点类型
typedefstruct
{
QNode*front,*rear;//将头、尾指针纳入到一个结构体的链队列
}LQueue;//链队列类型
voidInit_LQueue（LQueue**q）//创建一个带头结点的空队列
{
QNode*p;
*q=（LQueue*）malloc（sizeof（LQueue））;//申请带头、尾指针的结点
p=（QNode*）malloc（sizeof（QNode））;//申请链队列的头结点
p->next=NULL;//头结点的next指针置为空
（*q）->front=p;//队头指针指向头结点
（*q）->rear=p;//队尾指针指向头结点
}
intEmpty_LQueue（LQueue*q）//判队空
{
if（q->front==q->rear）
return1;//队为空
else
return0;
}
voidIn_LQueue（LQueue*q,charx）//入队
{
QNode*p;
p=（QNode*）malloc（sizeof（QNode））;//申请新链队列结点
p->data=x;
p->next=NULL;//新结点作为队尾结点时其next域为空
q->rear->next=p;//将新结点*p链到原队尾结点之后
q->rear=p;//是队尾指针指向新的队尾结点*p
}
voidOut_LQueue（LQueue*q,char*x）//出队
{
QNode*p;
if（Empty_LQueue（q））
printf（"Queueisempty!
\n"）;//队空，出队失败
else
{
p=q->front->next;//指针p指向队头结点
q->front->next=p->next;//头结点的next指针指向链队列的第二个数据结点
*x=p->data;//将删除的队头结点数据经由指针x返回
free（p）;
if（q->front->next==NULL）//出队后队为空，则置为空队列
q->rear=q->front;
}
}
voidprint（LQueue*q）//链队列输出
{
QNode*p;
p=q->front->next;
while（p!
=NULL）
{
printf（"%4c",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidmain（）
{
LQueue*q;
charx,*y=&x;//出队元素经指针y传给x
Init_LQueue（&q）;//链队列初始化
if（Empty_LQueue（q））//判队空
printf（"Queueisempty!
\n"）;
printf（"Inputanystring:
\n"）;//给链队列输入元素
scanf（"%c",&x）;
while（x!
='\n'）
{
In_LQueue（q,x）;
scanf（"%c",&x）;//元素入队
}
printf（"OutputelementsofQueue:
\n"）;
print（q）;//链队列输出
printf（"OutputQueue:
\n"）;
Out_LQueue（q,y）;//元素出队
printf（"ElementofOutputQueueis%c\n",*y）;//输出出队的元素值
printf（"OutputelementsofQueue:
\n"）;
print（q）;//输出出队后链队列的元素
}
四、实验总结：
通过本次试验，了解了栈和队列的基本操作。
从数据结构的定义看，栈和队列也是一种线性表。
其与线性表的不同之处在于栈和队列的相关运算具有特殊性，只是线性表相关运算的一个子集。
一般线性表的上的插入、删除运算不受限制，而栈和队列上的插入、删除运算受某种特殊限制。
因此。
栈和队列也称为操作受限的线性表。
升级会员 