栈和队列实验报告.docx

栈和队列实验报告.docx

《栈和队列实验报告.docx》由会员分享，可在线阅读，更多相关《栈和队列实验报告.docx（18页珍藏版）》请在冰豆网上搜索。

栈和队列实验报告

数据结构实验报告

顺序栈的实现和基本操作

一、需求分析

（1）顺序栈

◆栈的典型操作是入栈和出栈，前者将新元素压入栈中，后者弹出栈顶元素。

栈只提供对栈顶元素的访问操作，由top（）完成。

Push（）和Pop（）还有Top（）共同构成了栈的最小功能接口。

此外，为了方便使用，栈还有判空，判满和输出栈等功能。

◆输入形式及范围：

输入形式为整型，范围为0~65535。

◆输出形式：

在顺序栈的初始化后显示初始化成功，在判断栈是否为空时显示当前栈为空，入栈后显示入栈成功或者栈已满。

出栈时显示出栈元素或者栈为空。

输出栈时依次显示栈中元素。

◆程序功能：

初始化栈，判断栈是否为空，判断栈是否为满，入栈，出栈，取栈顶元素，出栈同时返回栈顶元素和输出栈等功能。

◆测试数据：

初始化后输入栈的长度为4。

判断栈是否为空。

进行5次入栈操作。

分别输入12345

输出栈。

执行2次出栈操作。

输出栈。

查看栈顶元素。

输出栈。

（2）队列

◆队列的典型操作是入队和出队，前者将新元素压入队列中，后者弹出队首头元素。

队列只提供对队头元素和队尾元素的操作，由DeQueue（）和EnQueue（）完成。

DeQueue还有EnQueue（）共同构成了队列的最小功能接口。

此外，为了方便使用，队列还有判空，判满和输出队列等功能。

◆输入形式及范围：

输入形式为整型，范围为0~65535。

◆输出形式：

在顺序队列的初始化后显示初始化成功，在判断队列是否为空时显示当前队列为空，入队列后显示入队成功或者队列已满。

出队列时显示出队首元素或者队列为空。

输出队列时依次显示队列中元素。

◆程序功能：

初始化队列，判断队列是否为空，判断队列是否为满，入队，出队，取队首元素，输出队列等功能。

◆测试数据：

初始化后输入队列的长度为54。

判断队列是否为空。

进行5次入队操作。

分别输入12345

输出队列。

执行2次出队操作。

输出队列。

查看队首元素。

输出队列。

二、概要设计

（1）顺序栈

◆为了实现程序的功能，在.H文件中定义了栈的模板类.

template

classStack

{

私有数据成员：

private:

栈的最大长度intMaxSize;

栈顶位置inttop;

顺序栈首地址T*theArray;

公有成员：

public:

栈的初始化voidInitStack（intcapacity=10）;

操作结果：

初始化一个默认长度为10的空栈

判断栈是否为空boolIsEmpty（）const;

初始条件：

栈已存在。

操作结果：

判断栈是否为空。

为空则返回1。

判断栈是否为满boolIsFull（）const;

初始条件：

栈已存在。

操作结果：

判断栈是否为满。

为满则返回1。

查看栈顶元素constT&Top（）const;

初始条件：

栈已经存在。

操作结果：

查看栈顶元素，且返回其值。

清空栈voidMakeEmpty（）{top=-1;}

初始条件：

栈已存在。

操作结果：

清空当前栈中元素。

出栈voidPop（）;

初始条件：

栈已存在。

操作结果：

将当前栈顶元素出栈。

栈为空时提醒当前栈为空。

入栈voidPush（constT&e）;

初始条件：

栈已存在。

操作结果：

将当前元素入栈。

栈为满时弹出提醒当前栈已满。

出栈且返回栈顶元素TTopAndPop（）;

初始条件：

栈已存在。

操作结果：

当前栈顶元素出栈且返回其值。

输出栈voidOutput（）;

初始条件：

栈已存在

操作结果：

按顺序输出栈中元素

};

◆模板类中包含了以下函数

初始化栈voidInitStack（intcapacity=10）;

判断栈空boolIsEmpty（）const;

判断栈满boolIsFull（）const;

查看栈顶元素constT&Top（）const;

置空栈voidMakeEmpty（）{top=-1;}

出栈voidPop（）;

入栈voidPush（constT&e）;

出栈且返回栈顶元素TTopAndPop（）;

输出栈voidOutput（）;

（2）队列

◆为了实现程序的功能，在.H文件中定义了队列的模板类.

template

classQueue

{

私有数据成员：

private:

队列的最大长度intMaxSize;

队列的当前位置IntcurrentSize;

队头位置intfront;

队尾位置intrear;

队列的头指针T*theArray;

自加函数voidIncrement（int&x）;

公有成员：

public:

队列的初始化voidInitQueue（intcapacity=10）;操作结果：

初始化一个默认长度为10的空队列

判断队列是否为空boolIsEmpty（）const;

初始条件：

队列已存在。

操作结果：

判断队列是否为空。

为空则返回1。

判断队列是否为满boolIsFull（）const;

初始条件：

队列已存在。

操作结果：

判断队列是否为满。

为满则返回1。

查看队列顶元素constT&GetFront（）const;

初始条件：

队列已经存在。

操作结果：

查看队列顶元素，且返回其值。

清空队列voidMakeEmpty（）;

初始条件：

队列已存在。

操作结果：

清空当前队列中元素。

出队列TDeQueue（）;

初始条件：

队列已存在。

操作结果：

将当前队列顶元素出队。

队列为空时提醒当前队列为空。

入队列voidEnQueue（constT&x）;

初始条件：

队列已存在。

操作结果：

将当前元素入队。

队列为满时弹出提醒当前队列已满。

输出队列voidOutPut（）;

初始条件：

队列已存在

操作结果：

按顺序输出队列中元素

};

◆模板类中包含了以下函数

初始化队列voidInitQueue（intcapacity=10）;

判断队列是否为空boolIsEmpty（）const;

判断队列是否为满boolIsFull（）const;

查看队头元素constT&GetFront（）const;

置空队列voidMakeEmpty（）;

出对TDeQueue（）;

入对voidEnQueue（constT&x）;

输出队列voidOutput（）;

◆运用main函数来调用实现以上功能

◆各个函数之间关系表示如下：

三、详细设计

（1）顺序栈

◆栈的初始化：

template

voidStack:

:

InitStack（intcapacity）

{

MaxSize=capacity;

theArray=newT[MaxSize];

top=-1;

}

◆判断栈空

template

boolStack:

:

IsEmpty（）const//判断栈是否为空如果空返回1

{

returntop==-1;

}

◆判断栈满

template

boolStack:

:

IsFull（）const//判断栈是否为满如果已满返回1

{

returntop==MaxSize-1;

}

◆入栈函数

template

voidStack:

:

Push（constT&e）//入栈

{

if（IsFull（））cout<<"栈已满，不能继续插入"<

theArray[++top]=e;

}

◆出栈函数：

template

voidStack:

:

Pop（）//出栈

{

if（IsEmpty（））cout<<"栈为空"<

top--;

}

◆出栈且返回栈顶元素：

template

TStack:

:

TopAndPop（）//返回栈顶元素且出栈

{

if（IsEmpty（））cout<<"栈为空"<

returntheArray[top--];

}

◆查看栈顶元素：

template

constT&Stack:

:

Top（）const//返回栈顶元素

{

if（IsEmpty（））cout<<"栈为空"<

returntheArray[top];

}

◆输出栈：

template

voidStack:

:

Output（）

{

if（IsEmpty（））cout<<"栈为空"<

inti;

for（i=0;i<=top;i++）

{

cout<

}

}

◆顺序main函数

#include

#include"malloc.h"

#include"stdlib.h"

#include"stack.h"

voidmain（）

{

Stackstack;

intselect;

do

{

cout<<"请选择所需操作：

"<

cout<<"\t\t1：

新建栈"<

cout<<"\t\t2：

判断栈是否为空"<

cout<<"\t\t3：

判断栈是否为满"<

cout<<"\t\t4：

入栈"<

cout<<"\t\t5：

出栈"<

cout<<"\t\t6：

查看栈顶元素"<

cout<<"\t\t7：

输出栈"<

cout<<"\t\t8：

退出程序"<

cin>>select;

switch（select）

{

case1:

{

intn;

cout<<"请输入栈长度（默认为10）"<

cin>>n;

stack.InitStack（n）;

system（"pause"）;system（"cls"）;

break;

}

case2:

{

if（stack.IsEmpty（）==1）

cout<<"当前栈为空"<

elsecout<<"当前栈非空"<

system（"pause"）;system（"cls"）;

break;

}

case3:

{

if（stack.IsFull（）==1）

cout<<"当前栈为满"<

elsecout<<"当前栈非满"<

system（"pause"）;system（"cls"）;

break;

}

case4:

{

intx;

cout<<"请输入即将入栈的元素值"<

cin>>x;

stack.Push（x）;

cout<<"入栈成功"<

system（"pause"）;system（"cls"）;

break;

}

case5:

{

inti,e;

e=stack.TopAndPop（）;

cout<<"是否查看刚刚出栈的元素？

（是，则输入1，否则输入0）"<

cin>>i;

if（i=1）cout<<"刚刚出栈元素值为：

"<

if（i!

=1&&i!

=0）cout<<"输入有误"<

system（"pause"）;system（"cls"）;

break;

}

case6:

{

cout<<"当前栈顶元素值为：

"<

system（"pause"）;system（"cls"）;

break;

}

case7:

{

cout<<"当前栈中元素为:

"<

stack.Output（）;

system（"pause"）;system（"cls"）;

break;

}

}

}

while（select>=1&&select<8）;

}

（2）队列

◆队列初始化

template

voidQueue:

:

InitQueue（intcapacity）

{

MaxSize=capacity;

theArray=newT[MaxSize];

front=0;

rear=-1;

}

◆判空

template

boolQueue:

:

IsEmpty（）const

{

returncurrentSize==0;

}

◆判满

template

boolQueue:

:

IsFull（）const

{

returncurrentSize==MaxSize;

}

template

voidQueue:

:

MakeEmpty（）

{

currenSize=0;

front=0;

rear=-1;

}

◆置空队列

template

voidQueue:

:

MakeEmpty（）

{

currenSize=0;

front=0;

rear=-1;

}

◆查看队头元素

template

constT&Queue:

:

GetFront（）const

{

if（IsEmpty（））cout<<"队列为空"<

returntheArray[front];

}

◆出队函数

template

TQueue:

:

DeQueue（）

{

if（IsEmpty（））cout<<"队列为空"<

currentSize--;

TfrontItem=theArray[front];

Increment（front）;

returnfrontItem;

}

◆入队函数

template

voidQueue:

:

EnQueue（constT&x）

{

if（IsFull（））cout<<"队列已满"<

Increment（rear）;

theArray[rear]=x;

currentSize++;

}

◆输出队列

template

voidQueue:

:

OutPut（）

{

if（IsEmpty（））cout<<"队列为空"<

inti;

for（i=front;i<=rear;i++）

{

cout<

}

}

◆队列main函数

#include

#include"malloc.h"

#include"stdlib.h"

#include"duilie.h"

voidmain（）

{

Queuequeue;

intselect;

do

{

cout<<"请选择所需操作：

"<

cout<<"\t\t1：

新建队列"<

cout<<"\t\t2：

判断队列是否为空"<

cout<<"\t\t3：

判断队列是否为满"<

cout<<"\t\t4：

入队"<

cout<<"\t\t5：

出队"<

cout<<"\t\t6：

查看队首元素"<

cout<<"\t\t7：

输出队列"<

cout<<"\t\t8：

退出程序"<

cin>>select;

switch（select）

{

case1:

{

intn;

cout<<"请输入队列长度（默认为10）"<

cin>>n;

queue.InitQueue（n）;

system（"pause"）;system（"cls"）;

break;

}

case2:

{

if（queue.IsEmpty（）==1）

cout<<"当前栈为空"<

elsecout<<"当前栈非空"<

system（"pause"）;system（"cls"）;

break;

}

case3:

{

if（queue.IsFull（）==1）

cout<<"当前队列为满"<

elsecout<<"当前队列非满"<

system（"pause"）;system（"cls"）;

break;

}

case4:

{

intx;

cout<<"请输入即将入队的元素值"<

cin>>x;

queue.EnQueue（x）;

cout<<"入队成功"<

system（"pause"）;system（"cls"）;

break;

}

case5:

{

inti,e;

e=queue.DeQueue（）;

cout<<"是否查看刚刚出栈的元素？

（是，则输入1，否则输入0）"<

cin>>i;

if（i=1）cout<<"刚刚出队元素值为：

"<

if（i!

=1&&i!

=0）cout<<"输入有误"<

system（"pause"）;system（"cls"）;

break;

}

case6:

{

cout<<"当前队首元素值为：

"<

system（"pause"）;system（"cls"）;

break;

}

case7:

{

cout<<"当前队列中元素为:

"<

queue.OutPut（）;

system（"pause"）;system（"cls"）;

break;

}

}

}

while（select>=1&&select<8）;

}

四、使用说明

顺序栈模板类的全部实现内容包含在一个独立的C++头文件stack.h中。

而为了实现该头文件里的函数以及其功能，又建立了一个main函数来使用该顺序栈的类头文件。

首先，先进行了模板类的实例化。

队列模板类的全部实现内容包含在一个独立的C++头文件stack.h中。

而为了实现该头文件里的函数以及其功能，又建立了一个main函数来使用该顺序栈的类头文件。

首先，先进行了模板类的实例化。

五、测试程序的运行结果

（1）顺序栈

1、选择1创建栈输入4，即创建长度为4的顺序栈

2、选择4入栈。

依次操作且输入1.2.3.4.5

3、选择7输出栈

4、两次选择5出栈

5、选择7输出栈

6、选择6查看栈顶元素

7、选择7输出栈

（2）队列

1、选择1创建队列，输入5即创建长度为5的队列

2、选择2判断队列是否为空

3、选择4入队。

依次操作且输入1.2.3.4.5

4、选择7输出队列

5、选择5出队

6、选择6查看队首元素

7、选择7输出队列

六、心得体会

学习完队列和栈一章后对其操作以及各个函数的运用有的了解。

本次的程序在调试的方面曾经多次出现问题，特别是开始时输入的数据出现了不能继续操作的情况，在同学的帮助下解决了这一问题，总体来看由于教材上有较多的实例，个人主要是完成主函数和各个函数的衔接，总体来说操作不是很复杂，但是需要时间进行调试。

通过这次试验进一步增强了对栈和队列原理的理解。