数据结构堆栈实验报告doc

数据结构堆栈实验报告
篇一：数据结构-堆栈和队列实验报告
实验报告
实验二堆栈和队列
实验目的：
1.熟悉栈这种特殊线性结构的特性；
2.熟练并掌握栈在顺序存储结构和链表存储结构下的基本运算；
3.熟悉队列这种特殊线性结构的特性；
3.熟练掌握队列在链表存储结构下的基本运算。

实验原理：
堆栈顺序存储结构下的基本算法；
堆栈链式存储结构下的基本算法；
队列顺序存储结构下的基本算法；
队列链式存储结构下的基本算法；
实验内容：
3-18 链式堆栈设计。

要求
（1）用链式堆栈设计实现堆栈，堆栈的操作集合要求包括：初始化StackInitiate（S）,非空否StackNotEmpty(S)，入栈StackiPush(S,x),出栈StackPop（S,d）,取栈顶数据元素StackTop(S,d);
（2）设计一个主函数对链式堆栈进行测试。

测试方法为：依次把数据元素1，2，3，4，5入栈，然后出栈并在屏幕上显示出栈的数据元素；
（3）定义数据元素的数据类型为如下形式的结构体，
Typedef struct
{
c(本文来自：小草范文网:数据结构堆栈实验报告)har taskName[10];
int taskNo;
}DataType;
首先设计一个包含5个数据元素的测试数据，然后设计一个主函数对链式堆栈进行测试，测试方法为：依次吧5个数据元素入栈，然后出栈并在屏幕上显示出栈的数据元素。

3-19 对顺序循环队列，常规的设计方法是使用対尾指针和对头指针，对尾指针用于指示当前的対尾位置下标，对头指针用于指示当前的対头位置下标。

现要求：
（1）设计一个使用对头指针和计数器的顺序循环队列抽象数据类型，其中操作包括：初始化，入队列，出队列，取对头元素和判断队列是否为空；
（2）编写一个主函数进行测试。

实验结果：
3-18
typedef struct snode
{
DataType data;
struct snode *next;
} LSNode;
/*初始化操作：*/
void StackInitiate(LSNode **head)
/*初始化带头结点链式堆栈*/
{
if((*head = (LSNode *)malloc(sizeof(LSNode))) == NULL) exit(1); (*head)->next = NULL;
}
/*判非空操作：*/
int StackNotEmpty(LSNode *head)
/*判堆栈是否非空，非空返回1；空返回0*/
{
if(head->next == NULL) return 0;
else return 1;
}
/*入栈操作：*/
int StackPush(LSNode *head, DataType x)
/*把数据元素x插入链式堆栈head的栈顶作为新的栈顶 */ {
LSNode *p;
if((p = (LSNode *)malloc(sizeof(LSNode))) == NULL)
{
printf("内存空间不足无法插入! \n");
return 0;
}
p->data = x;
p->next = head->next; /*新结点链入栈顶*/ head->next = p;/*新结点成为新的栈顶*/ return 1;
}
/*出栈操作：*/
int StackPop(LSNode *head, DataType *d)
/*出栈并把栈顶元素由参数d带回*/
{
LSNode *p = head->next;
if(p == NULL)
{
printf("堆栈已空出错！");
return 0;
}
head->next = p->next;/*删除原栈顶结点*/ *d = p->data; /*原栈顶结点元素赋予d*/ free(p); /*释放原栈顶结点内存空间*/ return 1;
}
/*取栈顶数据元素操作：*/
int StackTop(LSNode *head, DataType *d)
/*取栈顶元素并把栈顶元素由参数d带回*/
{
LSNode *p = head->next;
if(p == NULL)
{
printf("堆栈已空出错！");
return 0;
}
*d = p->data;
return 1;
}
/*撤销*/
void Destroy(LSNode *head)
{
LSNode *p, *p1;
p = head;
while(p != NULL)
{
p1 = p;
p = p->next;
free(p1);
}
}（2）主函数程序：
#include
#include
typedef int DataType;
#include "LinStack.h"
void main(void)
{ LSNode *myStack;
int i, x;
StackInitiate(&myStack);
for(i=0;i { if(StackPush(myStack,i+1)==0) {
printf("error!\n");
return;
}
}
if(StackTop(myStack, &x)==0)
{
printf("error!\n");
return;
}
else
printf("The element of local top is :%d\n",x); printf( "The sequence of outing elements is:\n"); while(StackNotEmpty(myStack))
{
StackPop(myStack, &x);
printf("%d ", x);
}
printf("\n");
Destroy(myStack);
printf("This program is made by\n"); }
运行结果为：
（3）设计结构体和测试函数如下：
#include
#include
#include
typedef struct{
char taskName[10];
int taskNo;
}DataType;
#include"LinStack.h"
void main(){
LSNode *myStack;
FILE *fp;
DataType task,x;
if((fp=fopen("task.txt","r"))==NULL){
printf("不能打开文件task.txt!\n");
exit(0);
}
StackInitiate(&myStack);
while(!feof(fp)){
fscanf(fp,"%s %d",&task.taskName,&task.taskNo); StackPush(myStack,task);
}
fclose(fp);
while(StackNotEmpty(myStack)){
StackPop(myStack,&x);
printf("%s %d\n",x.taskName,x.taskNo); } Destroy(myStack);
printf("This program is made by \n");
}运行结果为：
3-19
（1）
typedef struct
{
DataType queue[MaxQueueSize];
int front; /*队头指针*/
int count;/*计数器*/
} SeqCQueue;
/*初始化操作：QueueInitiate(SeqCQueue *Q) */ void QueueInitiate(SeqCQueue *Q)
/*初始化顺序循环队列Q */
{
Q->front=0; /*定义初始队头指针下标*/
Q->count=0;/*定义初始计数器值*/
}
/*判非空否操作：QueueNotEmpty(SeqCQueue Q)*/ int QueueNotEmpty(SeqCQueue Q)
篇二：数据结构栈和队列实验报告
一、实验目的和要求
(1)理解栈和队列的特征以及它们之间的差异，知道在何时使用那种数据结构。

(2)重点掌握在顺序栈上和链栈上实现栈的基本运算算法，注意栈满和栈空的条件。

(3)重点掌握在顺序队上和链队上实现队列的基本运算算法，注意循环队队列满和队空的条件。

(4)灵活运用栈和队列这两种数据结构解决一些综合应用问题。

二、实验环境和方法
实验方法：
（一）综合运用课本所学的知识，用不同的算法实现在不同的程序功能。

（二）结合指导老师的指导，解决程序中的问题，正确解决实际中存在的异常情况，逐步改善功能。

（三）根据实验内容，编译程序。

实验环境：Windows xpVisual C++6.0
三、实验内容及过程描述
实验步骤：
①进入Visual C++ 6.0集成环境。

②输入自己编好的程序。

③检查一遍已输入的程序是否有错（包括输入时输错的和编程中的错误），如发现有
错，及时改正。

④进行编译和连接。

如果在编译和连接过程中发现错误，频幕上会出现“报错信息”，
根据提示找到出错位置和原因，加以改正。

再进行编译，如此反复直到不出错为止。

⑤运行程序并分析运行结果是否合理。

在运行是要注意当输入不同的数据时所得结果是否正确，应运行多次，分别检查在不同情况下结果是否正确。

实验内容：编译以下题目的程序并调试运行。

1）、编写一个程序algo3-1.cpp，实现顺
的各种基本运算，并在此基础上设计一
程序并完成如下功能：
（1）初始化栈s；
（2）判断栈s是否非空；序栈个主
（3）依次进栈元素a,b,c,d,e；
（4）判断栈s是否非空；
（5）输出出栈序列；
（6）判断栈s是否非空；
（7）释放栈。

图3.1 Proj3_1 工程组成
本工程Proj3_1的组成结构如图3.1所示。

本工程的模块结构如图3.2所示。

图中方框表示函数，方框中指出函数名，箭头方向表示函数间的调用关系。

图3.2 Proj3_1工程的程序结构图
其中包含如下函数：
InitStack(SqStack *&s) //初始化栈S
DestroyStack(SqStack *&s) //销毁栈s
StackEmpty(SqStack *s) //判断栈空
Push(SqStack *&s,ElemType e) //进栈
Pop(SqStack *&s,ElemType &e) //出栈
GetTop(SqStack *s,ElemType &e) //取栈顶元素
对应的程序如下：
//文件名:algo3-1.cpp
#include
#include
#define MaxSize 100
typedef char ElemType;
typedef struct
{
ElemType data[MaxSize];
int top; //栈顶指针
} SqStack;
void InitStack(SqStack *&s) //初始化栈S
{ s=(SqStack *)malloc(sizeof(SqStack));
s->top=-1; //栈顶指针置为-1
}
void DestroyStack(SqStack *&s) //销毁栈s
{
free(s);
}
bool StackEmpty(SqStack *s) //判断栈空
{
return(s->top==-1);
}
bool Push(SqStack *&s,ElemType e) //进栈
{ if (s->top==MaxSize-1) //栈满的情况，即栈上溢出
return false;
s->top++; //栈顶指针增1
s->data[s->top]=e; //元素e放在栈顶指针处
return true;
}
bool Pop(SqStack *&s,ElemType &e) //出栈
{ if (s->top==-1) //栈为空的情况，即栈下溢出
return false;
e=s->data[s->top]; //取栈顶指针元素的元素
s->top--;//栈顶指针减1
return true;
}
bool GetTop(SqStack *s,ElemType &e) //取栈顶元素
{ if (s->top==-1) //栈为空的情况，即栈下溢出
return false;
e=s->data[s->top]; //取栈顶指针元素的元素
return true;
}
设计exp3-1.cpp程序如下 //文件名:exp3-1.cpp
#include
#include
#define MaxSize 100
typedef char ElemType;
typedef struct
{
ElemType data[MaxSize];
int top; //栈顶指针
} SqStack;
extern void InitStack(SqStack *&s);
extern void DestroyStack(SqStack *&s); extern bool StackEmpty(SqStack *s);
extern bool Push(SqStack *&s,ElemType e); extern bool Pop(SqStack *&s,ElemType &e); extern bool GetTop(SqStack *s,ElemType &e); void main()
{
ElemType e;
SqStack *s;
printf("栈s的基本运算如下:\n");
printf(" (1)初始化栈s\n");
InitStack(s);
printf(" (2)栈为%s\n",(StackEmpty(s)?"空":"非空"));
printf(" (3)依次进栈元素a,b,c,d,e\n");
Push(s,'a');
Push(s,'b');
Push(s,'c');
Push(s,'d');
Push(s,'e');
printf(" (4)栈为%s\n",(StackEmpty(s)?"空":"非空"));
printf(" (5)出栈序列:");
while (!StackEmpty(s))
{
Pop(s,e);
printf("%c ",e);
}
printf("\n");
printf(" (6)栈为%s\n",(StackEmpty(s)?"空":"非空"));
printf(" (7)释放栈\n");
DestroyStack(s);
}
运行结果如下：
2）、编写一个程序algo3-2.cpp，实现链栈的各种基本运算，并在此基础上设计一个主程序并完成如下功能：（1）初始化链栈s；
（2）判断链栈s是否非空；
（3）依次进栈a，b，c，d，e；
（4）判断链栈s是否非空；
（5）输出链栈长度；
（6）输出从栈底到栈顶元素；
（7）输出出队序列；
（8）判断链栈s是否非空；图3.3 Proj3_2工程组成（9）释放队列。

本工程Proj3_2的组成结构如图3.3所示。

本工程的模块结构如图3.4所示。

图中方框表示函数，方框中指出函数名，箭头方向表示函数间的调用关系。

图3.4 Proj3_2工程的程序结构图
其中包含如下函数：
InitStack(LiStack *&s) //初始化栈s
DestroyStack(LiStack *&s) //销毁栈
StackEmpty(LiStack *s) //判断栈是否为空
Push(LiStack *&s,ElemType e) //进栈
Pop(LiStack *&s,ElemType &e) //出栈
GetTop(LiStack *s,ElemType &e) //取栈顶元素
对应的程序如下：
//文件名:algo3-2.cpp
#include
#include
typedef char ElemType;
typedef struct linknode
{
ElemType data; //数据域
篇三：数据结构栈与队列的实验报告
数据结构栈与队列实验报告
学院：数学与计算机学院班级：计算机科学与技术姓名：杨理源
学号：XX
实验三栈与队列
一、实验目的：
（1）熟练掌握栈和队列的结构以及这两种数据结构的特点、栈与队列的基本操作。

（2）能够在两种存储结构上实现栈的基本运算，特别
注意栈满和栈空的判断条件及描述方法；
（3）熟练掌握链队列和循环队列的基本运算，并特别注意队列满和队列空的判断条件和描述方法；
（4）掌握栈的应用；
二、实验要求：
(1) 给出程序设计的基本思想、原理和算法描述。

(2) 对源程序给出注释。

(3) 记录程序的运行结果，并结合程序进行分析。

三、程序设计的基本思想、原理和算法描述：
四、实验内容：
1、利用栈的基本操作将一个十进制的正整数转换成R 进制数据，并将其转换结果输出。

#include
#include
#include
#define stack_init_size 100
#define stackincrement 10
typedef struct sqstack {
int *base;
int *top;
int stacksize;
} sqstack;
int StackInit(sqstack *s)
{s->base=(int *)malloc(stack_init_size *sizeof(int));
if(!s->base)
return 0;
s->top=s->base;
s->stacksize=stack_init_size;
return 1;
}
int Push(sqstack *s,int e)
{
if(s->top-s->base>=s->stacksize)
{
s->base=(int *)realloc(s->base,(s->stacksize+stackincrement)*siz eof(int));if(!s->base)
return 0;
s->top=s->base+s->stacksize;
s->stacksize+=stackincrement;
}
*(s->top++)=e;
return e;
}
int Pop(sqstack *s,int e) {
if(s->top==s->base)
return 0;
e=*--s->top;
return e;
}
int stackempty(sqstack *s) {
if(s->top==s->base)
{
return 1;
}
else
{
return 0;
}
}
int conversion(sqstack *s)
{
int n,e=0,flag=0;
printf("
输入要转化的十进制数：
\n");
scanf("%d",&n);
printf("要转化为多少进制：2 进制、8 进制、16 进制填数字！\n"); scanf("%d",&flag);
printf("将十进制数%d 转化为%d 进制是：\n",n,flag);
while(n)
{
Push(s,n%flag);
n=n/flag; }
while(!stackempty(s))
{
e=Pop(s,e);
switch(e)
{
case 10: printf("A");
break;
case 11: printf("B"); break;
case 12: printf("C"); break;
case 13: printf("D"); break;
case 14: printf("E"); break;
case 15: printf("F"); break;
default: printf("%d",e); } }
printf("\n");
return 0;}
int main()
{
sqstack s;
StackInit(&s);
conversion(&s);
return 0;
}
2、回文数判断
#include
#include
#define MAX 50
#define FALSE 0
#define TURE 1
//定义栈
typedef struct
{
char elem[MAX];
int top;
}SeqStack;
//定义循环队列
typedef struct
{
char element[MAX];
int front;
int rear;
}SeqQuene;
//初始化栈
void InitStack(SeqStack *S) {
S->top = -1;//构造一个空栈 }
//入栈
int Push(SeqStack *S,char x,int cnt) { if(S->top == cnt-1)
return(FALSE);
S->top++;
S->elem[S->top] = x;。