数据结构实验---堆栈

合集下载

堆栈模拟队列实验报告

一、实验目的通过本次实验，加深对堆栈和队列数据结构的理解，掌握堆栈的基本操作，并学会利用堆栈模拟队列的功能。

通过实验，培养学生的编程能力和问题解决能力。

二、实验内容1. 实现一个顺序堆栈，包括初始化、判断是否为空、入栈、出栈等基本操作。

2. 利用两个顺序堆栈实现队列的功能，包括入队、出队、判断队列是否为空等操作。

3. 通过实例验证模拟队列的正确性。

三、实验原理队列是一种先进先出（FIFO）的数据结构，而堆栈是一种后进先出（LIFO）的数据结构。

本实验通过两个堆栈来实现队列的功能。

当元素入队时，将其压入第一个堆栈（称为栈A）；当元素出队时，先从栈A中依次弹出元素并压入第二个堆栈（称为栈B），直到弹出栈A中的第一个元素，即为队首元素。

四、实验步骤1. 定义堆栈的数据结构，包括堆栈的最大容量、当前元素个数、堆栈元素数组等。

2. 实现堆栈的基本操作，包括初始化、判断是否为空、入栈、出栈等。

3. 实现模拟队列的功能，包括入队、出队、判断队列是否为空等。

4. 编写主函数，创建两个堆栈，通过实例验证模拟队列的正确性。

五、实验代码```c#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} SeqStack;// 初始化堆栈void InitStack(SeqStack S) {S->top = -1;}// 判断堆栈是否为空int IsEmpty(SeqStack S) {return S->top == -1;}// 入栈int Push(SeqStack S, int x) {if (S->top == MAX_SIZE - 1) { return 0; // 堆栈已满}S->data[++S->top] = x;return 1;}// 出栈int Pop(SeqStack S, int x) {if (IsEmpty(S)) {return 0; // 堆栈为空}x = S->data[S->top--];return 1;}// 队列的入队操作void EnQueue(SeqStack S, SeqStack Q, int x) { Push(S, x);}// 队列的出队操作int DeQueue(SeqStack S, SeqStack Q, int x) { if (IsEmpty(Q)) {while (!IsEmpty(S)) {int temp;Pop(S, &temp);Push(Q, temp);}}if (IsEmpty(Q)) {return 0; // 队列为空}Pop(Q, x);return 1;}int main() {SeqStack S, Q;int x;InitStack(&S);InitStack(&Q);// 测试入队操作EnQueue(&S, &Q, 1);EnQueue(&S, &Q, 2);EnQueue(&S, &Q, 3);// 测试出队操作while (DeQueue(&S, &Q, &x)) {printf("%d ", x);}return 0;}```六、实验结果与分析1. 通过实例验证，模拟队列的入队和出队操作均正确实现了队列的先进先出特性。

实验报告堆栈操作

一、实验目的1. 理解堆栈的基本概念和原理；2. 掌握堆栈的基本操作，包括入栈、出栈、取栈顶元素等；3. 熟悉堆栈在编程中的应用，提高编程能力。

二、实验原理堆栈是一种后进先出（Last In First Out, LIFO）的数据结构，它由一系列元素组成，遵循“先进后出”的原则。

在堆栈中，新元素总是被添加到栈顶，而移除元素时，总是从栈顶开始。

堆栈的基本操作包括：1. 初始化：创建一个空堆栈；2. 入栈：将一个元素添加到堆栈的顶部；3. 出栈：从堆栈中移除顶部元素；4. 取栈顶元素：获取堆栈顶部的元素，但不从堆栈中移除；5. 判断堆栈是否为空：检查堆栈中是否还有元素。

三、实验器材1. 计算机软件：C/C++编译器；2. 程序代码编辑器：例如Visual Studio、Code::Blocks等。

四、实验步骤1. 初始化堆栈：创建一个空堆栈，并设置栈的最大容量。

2. 入栈操作：（1）检查堆栈是否已满，如果已满，则无法入栈；（2）将元素添加到堆栈的顶部。

3. 出栈操作：（1）检查堆栈是否为空，如果为空，则无法出栈；（2）从堆栈中移除顶部元素。

4. 取栈顶元素操作：（1）检查堆栈是否为空，如果为空，则无法取栈顶元素；（2）获取堆栈顶部的元素。

5. 判断堆栈是否为空操作：（1）检查堆栈中的元素个数，如果为0，则堆栈为空。

6. 编写程序实现上述操作，并进行测试。

五、实验结果与分析1. 初始化堆栈：创建一个最大容量为10的空堆栈。

2. 入栈操作：（1）入栈元素1，堆栈状态：[1]；（2）入栈元素2，堆栈状态：[1, 2]；（3）入栈元素3，堆栈状态：[1, 2, 3]。

3. 出栈操作：（1）出栈元素3，堆栈状态：[1, 2]；（2）出栈元素2，堆栈状态：[1]。

4. 取栈顶元素操作：（1）取栈顶元素1，栈顶元素为1。

5. 判断堆栈是否为空操作：（1）判断堆栈是否为空，结果为“否”。

六、实验结论通过本次实验，我们掌握了堆栈的基本概念、原理和操作。

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案

{
x=Pop(s); /*出栈*/
printf("%d ",x);
InQueue(sq,x); /*入队*/
}
printf("\n");
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
ElemType Pop(SeqStack *s); /*出栈*/
ElemType GetTop(SeqStack *s); /*取栈顶元素*/
void DispStack(SeqStack *s); /*依次输出从栈顶到栈底的元素*/
void DispBottom(SeqStack *s); /*输出栈底元素*/
} SeqQueue; /*定义顺序队列*/
void InitStack(SeqStack *s); /*初始化栈*/
int StackEmpty(SeqStack *s); /*判栈空*/
int StackFull(SeqStack *s); /*判栈满*/
void Push(SeqStack *s,ElemType x); /*进栈*/
sq=(SeqQueue *)malloc(sizeof(SeqQueue));
InitQueue(sq);
printf("(8)队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
printf("(9)出栈/入队的元素依次为:");

北京交通大学-数据结构上机实验-2

数据结构上机实验二实验内容:栈和链队列的基本操作实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对堆栈和队列的理解.实验要求:1) 栈和队列的显示要作为函数被调用.2) 把自己使用的栈和队列结构明确的表达出来.分组要求：可单独完成，也可两人一组。

评分标准：1) 只完成第一或第二题，3分；2）完成一和二题，得5分；3）在2）基础上，可选做三）中的题目。

题目:一)堆栈题（顺序栈）:创建一个栈+入栈+出栈(1)由键盘一个一个的输入正整数，建立相应的堆栈，输入-1时，堆栈结束；(2)在（1）中创建的堆栈中添加一个元素；(3)在（1）中创建的堆栈中删除一个元素；(要求在显示器可见)；#include<stdio.h>#include<stdlib.h>#include <string>#define OK 1#define ERROR 0#define Status int#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct Stack{int *base;int *top;Status stacksize;}SqStack;Status CreatStack(SqStack &S) //创建空栈{S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status InStack(SqStack &S) //创建栈元素{int e;printf("请输入初始栈元素:\n");scanf("%d",&e);while(e!=-1){if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;scanf("%d",&e);}return OK;}Status Push(SqStack &S,int e) //栈加元素{if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,int e) //栈中删除元素{if(S.top==S.base) return ERROR;e=*--S.top;printf("\n请输出出栈元素:%d",e);printf("\n");return OK;}void print(){printf("\n菜单：");printf("\n1.由键盘一个一个的输入正整数，建立相应的堆栈，输入-1时，堆栈结束：");printf("\n2.在创建的堆栈中添加一个元素：");printf("\n3.在创建的堆栈中删除一个元素：");printf("\n3.退出");}void printS(SqStack &S) //打印堆栈{int *p;printf("请输出堆栈中的元素:\n");for(p=S.base;p<S.top;p++){printf("%d ",*p);}}void main() //主程序{SqStack S;int e,choice;do{print();printf("\n请输入选项：");scanf("%d",&choice);switch(choice){case 1:if(CreatStack(S)==1){if(InStack(S)==1)printS(S);}break;case 2:printf("\n请输入入栈元素：");scanf("%d",&e);Push(S,e);printS(S);break;case 3:Pop(S,e);printS(S);break;case 4:exit(0);break;}}while(1);}二)链队列题目：初始化队列+入队列+出队列+销毁队列(1)初始化一个链队列；(2)在初始化好的链队列中放入数，入队列，完成后要求显示；(3)从队列中出队列，要求显示出来的元素和之后的队列；(4)销毁创建的队列，释放内存；#include <stdio.h>#include <malloc.h>typedef struct Qnode{//队列结点int data;struct Qnode *next;}QNode, *QueuePtr;typedef struct {QueuePtr front; //队头指针QueuePtr rear; //队尾指针}LinkQueue;void InitQueue(LinkQueue &Q){ //初始化链队列Q.front=Q.rear=(QueuePtr) malloc(sizeof(QNode));Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int e){//入队列QueuePtr p;while(e!=-1){p=(QueuePtr)malloc(sizeof(QNode));p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;scanf("%d",&e);}}int QueueLength (LinkQueue Q){//求队列长度QueuePtr p;p=Q.front->next; //p指向队头int i=1;while(p!=Q.rear){ //遍历链队列,统计结点数i++;p=p->next;}return i;}// QueueLengthvoid DeQueue(LinkQueue &Q){ //出队列QueuePtr p;int e;if(Q.front==Q.rear)printf("The queue is empty\n");else{p=Q.front->next;e=p->data;printf("The delete elem is:%d\n",e);Q.front->next=p->next;if(Q.rear==p) Q.rear=Q.front;free(p);}printf("The new queue is :\n");}void DestroyQueue(LinkQueue &Q){ //销毁队列while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}}void QueueTraverse (LinkQueue Q){//遍历显示队列QueuePtr p;for(p=Q.front->next;p!=Q.rear;p=p->next)printf("%d ",p->data);printf("%d ",p->data);}void main(){LinkQueue Q;int e;InitQueue(Q);printf("Put in the elems:\n");scanf("%d",&e);EnQueue(Q,e);printf("The queue is:\n");QueueTraverse(Q);printf("\n");DeQueue(Q);QueueTraverse(Q);printf("\n");DestroyQueue(Q);}三）应用题（1）编制程序，将输入的十进制数据M 转换为八进制数据M8，将其调试通过。

堆栈的实验报告

一、实验目的1. 理解堆栈的基本概念和原理；2. 掌握堆栈的顺序存储和链式存储方法；3. 熟悉堆栈的基本操作，如入栈、出栈、判断栈空、求栈顶元素等；4. 能够运用堆栈解决实际问题。

二、实验内容1. 堆栈的基本概念和原理；2. 堆栈的顺序存储和链式存储方法；3. 堆栈的基本操作实现；4. 堆栈的应用实例。

三、实验原理1. 堆栈的基本概念和原理：堆栈是一种特殊的线性表，它按照“后进先出”（LIFO）的原则组织数据。

即最后进入堆栈的数据元素最先出栈。

2. 堆栈的顺序存储方法：使用一维数组实现堆栈，栈顶指针top指向栈顶元素。

3. 堆栈的链式存储方法：使用链表实现堆栈，每个节点包含数据域和指针域。

4. 堆栈的基本操作实现：（1）入栈：将元素插入到栈顶，如果栈未满，则top指针加1，并将元素值赋给top指向的元素。

（2）出栈：删除栈顶元素，如果栈不为空，则将top指向的元素值赋给变量，并将top指针减1。

（3）判断栈空：如果top指针为-1，则表示栈为空。

（4）求栈顶元素：如果栈不为空，则将top指向的元素值赋给变量。

四、实验步骤1. 使用顺序存储方法实现堆栈的基本操作；2. 使用链式存储方法实现堆栈的基本操作；3. 编写程序，测试堆栈的基本操作是否正确；4. 分析实验结果，总结实验经验。

五、实验结果与分析1. 使用顺序存储方法实现堆栈的基本操作：（1）入栈操作：当栈未满时，将元素插入到栈顶。

（2）出栈操作：当栈不为空时，删除栈顶元素。

（3）判断栈空：当top指针为-1时，表示栈为空。

（4）求栈顶元素：当栈不为空时，返回top指向的元素值。

2. 使用链式存储方法实现堆栈的基本操作：（1）入栈操作：创建新节点，将其作为栈顶元素，并修改top指针。

（2）出栈操作：删除栈顶元素，并修改top指针。

（3）判断栈空：当top指针为NULL时，表示栈为空。

（4）求栈顶元素：返回top指针指向的节点数据。

3. 实验结果分析：通过实验，验证了顺序存储和链式存储方法实现的堆栈基本操作的正确性。

实验二堆栈和队列基本操作的编程实现

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY
数据结构
实验报告
实验二堆栈和队列基本操作的编程实现
【实验目的】
堆栈和队列基本操作的编程实现
要求：
堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】
验证性实验（学时数：2H）
【实验内容】
内容：把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。

可以实验一的结果自己实现数据输入、数据显示的函数。

利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。

【注意事项】
1.开发语言：使用C。

2.可以自己增加其他功能。

【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)。

堆栈实验报告

堆栈实验报告堆栈实验报告引言：堆栈是一种常见的数据结构，它具有先进后出（Last In First Out）的特点，类似于我们日常生活中的堆叠书籍或者盘子的方式。

本次实验旨在通过实际操作和观察，深入了解堆栈的原理和应用。

实验目的：1. 理解堆栈的基本概念和特点；2. 学会使用堆栈进行数据的存储和检索；3. 掌握堆栈的应用场景和实际意义。

实验材料：1. 一台计算机；2. 编程语言环境（如C++、Java等）；3. 实验所需的数据集。

实验步骤：1. 确定实验所需的数据集，并将其准备好；2. 创建一个堆栈数据结构的类或者使用现有的堆栈库；3. 将数据集中的元素依次压入堆栈；4. 检索堆栈顶部的元素，并将其输出；5. 从堆栈中弹出一个元素，并将其输出；6. 重复步骤4和步骤5，直到堆栈为空。

实验结果与分析：通过实验操作，我们观察到以下现象和结果：1. 压入堆栈的元素按照先后顺序被存储，并且最后一个压入的元素位于堆栈的顶部；2. 检索堆栈顶部的元素时，我们可以获取到最后一个压入的元素；3. 弹出堆栈顶部的元素后，我们可以获取到倒数第二个压入的元素；4. 当堆栈为空时，无法再进行弹出操作。

根据实验结果，我们可以得出以下结论：1. 堆栈适用于需要按照先后顺序存储和检索数据的场景；2. 堆栈可以有效地实现数据的后进先出的处理方式；3. 堆栈的应用范围广泛，如函数调用、表达式求值等。

实验总结：通过本次实验，我们深入了解了堆栈的原理和应用。

堆栈作为一种重要的数据结构，在计算机科学领域中具有广泛的应用。

它不仅可以用于数据的存储和检索，还可以用于解决实际问题中的一些复杂计算和操作。

通过实际操作和观察，我们更加清晰地认识到堆栈的特点和优势。

然而，本次实验只是对堆栈的初步认识和应用，还有许多深入的研究和探索可以展开。

例如，我们可以进一步研究堆栈的实现原理和性能优化，探索堆栈在不同领域的应用案例，以及与其他数据结构的比较和结合等。

堆栈进制转换实验报告

一、实验目的1. 理解堆栈的基本原理和操作。

2. 掌握利用堆栈实现进制转换的方法。

3. 提高编程能力，培养问题解决能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理进制转换是将一个数从一种进制表示转换为另一种进制表示的过程。

例如，将十进制数转换为二进制数、十六进制数等。

堆栈是一种先进后出（FILO）的数据结构，可以用来实现进制转换。

进制转换的原理如下：1. 将十进制数转换为任意进制数，需要不断除以目标进制，直到商为0。

2. 将每次除法得到的余数存储在堆栈中，最后从堆栈中取出余数，倒序输出即为转换后的结果。

四、实验步骤1. 定义一个堆栈结构体，包含栈顶指针、栈底指针、栈大小和栈元素。

2. 实现堆栈的基本操作，如初始化、入栈、出栈和判断是否为空。

3. 编写进制转换函数，将十进制数转换为任意进制数。

4. 编写主函数，实现用户输入、进制转换和输出转换结果。

五、实验代码```cpp#include <iostream>#include <stack>using namespace std;// 堆栈结构体定义template <typename T>struct Stack {T base;T top;int size;int capacity;};// 初始化堆栈template <typename T>void initStack(Stack<T>& s, int capacity) { s.base = new T[capacity];s.top = s.base;s.size = 0;s.capacity = capacity;}// 入栈template <typename T>bool push(Stack<T>& s, T element) {if (s.size >= s.capacity) {return false;}s.top = element;s.top++;s.size++;return true;}// 出栈template <typename T>bool pop(Stack<T>& s, T& element) { if (s.size <= 0) {return false;}s.top--;element = s.top;s.size--;return true;}// 判断堆栈是否为空template <typename T>bool isEmpty(Stack<T>& s) {return s.size == 0;}// 十进制数转换为任意进制数template <typename T>void decimalToBase(T decimal, int base) { stack<T> resultStack;while (decimal > 0) {resultStack.push(decimal % base); decimal /= base;}while (!resultStack.empty()) {T element;pop(resultStack, element);cout << element;}cout << endl;}int main() {int decimal;int base;cout << "请输入十进制数：";cin >> decimal;cout << "请输入目标进制（2-16）："; cin >> base;if (base < 2 || base > 16) {cout << "目标进制无效！" << endl;return 0;}cout << "转换后的" << base << "进制数为：";decimalToBase(decimal, base);return 0;}```六、实验结果与分析1. 当输入十进制数65和进制8时，程序输出101，符合预期。

数据结构堆栈实验报告

数据结构堆栈实验报告篇一：数据结构-堆栈和队列实验报告实验报告实验二堆栈和队列实验目的：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-18typedef 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#includetypedef 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;}elseprintf("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#includetypedef 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)理解栈和队列的特征以及它们之间的差异，知道在何时使用那种数据结构。

堆栈及队列的应用实验原理

堆栈及队列的应用实验原理1. 实验介绍本实验将介绍堆栈和队列的基本概念及其应用原理。

首先，我们将学习堆栈和队列的定义和特点，并分析它们在编程中的常见应用场景。

然后，我们将通过实验来深入了解堆栈和队列的运作原理以及如何使用它们解决实际问题。

2. 堆栈的应用原理堆栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，类似于现实生活中的一叠盘子。

堆栈的应用原理基于以下几个操作：•压栈（Push）：将元素添加到堆栈的顶部。

•弹栈（Pop）：将栈顶的元素移除，并返回被移除的元素。

•查看栈顶（Peek）：只查看栈顶的元素，不对堆栈做任何修改。

堆栈的应用可以解决许多问题，例如：1.函数调用和递归：当一个函数调用另一个函数时，调用的函数会先被推入堆栈，直到被调函数返回结果后再从堆栈中弹出。

2.语法解析：语法解析器通常使用堆栈来验证和处理表达式、括号匹配等问题。

3.浏览器历史记录：浏览器的“后退”和“前进”功能可以使用堆栈来实现。

3. 队列的应用原理队列（Queue）是一种先进先出（First In First Out, FIFO）的数据结构，类似于现实生活中的排队。

队列的应用原理基于以下几个操作：•入队（Enqueue）：将元素添加到队列的尾部。

•出队（Dequeue）：将队列的头部元素移除，并返回被移除的元素。

•查看队头（Front）：只查看队列的头部元素，不对队列做任何修改。

队列的应用可以解决许多实际问题，例如：1.任务调度：处理任务的程序通常使用队列来管理待处理的任务列表。

2.消息传递：消息队列是分布式系统中常用的通信方式，用于实现异步处理和解耦系统组件。

3.缓冲区管理：队列用于控制多个生产者和消费者之间的数据传递，以避免资源竞争。

4. 实验步骤本实验将使用编程语言来模拟堆栈和队列的应用原理。

具体步骤如下：1.定义堆栈类和队列类：创建一个堆栈类和一个队列类，分别实现堆栈和队列的基本操作。

栈和队列基本操作实验报告

栈和队列基本操作实验报告实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求:堆栈和队列基本操作的编程实现(2学时，验证型)，掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】验证性实验(学时数:2H)【实验内容】内容:把堆栈和队列的顺序存储(环队)和链表存储的数据进队、出队等运算其中一部分进行程序实现。

可以实验一的结果自己实现数据输入、数据显示的函数。

利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。

【实验分析、说明过程】分析:进栈操作先创建一个以x为值的新结点p，其data域值为x则进栈操作步骤如下: 将新结点p的指针域指向原栈顶S(执行语句p->next=S)。

将栈顶S指向新结点p(执行语句S=p)。

注:进栈操作的?与?语句执行顺序不能颠倒，否则原S指针其后的链表将丢失。

出栈操作先将结点栈顶S数据域中的值赋给指针变量*x，则删除操作步骤如下: 结点p 指针域指向原栈顶S(执行语句p=S)。

栈顶S指向其的下一个结点(执行语句S=S->next)释放p结点空间(执行语句free(p))。

队列分析:用链式存储结构实现的队列称为链队列，一个链队列需要一个队头指针和一个队尾指针才能唯一确定。

队列中元素的结构和前面单链表中的结点的结构一样。

为了操作方便，在队头元素前附加一个头结点，队头指针就指向头结点。

【思考问题】1. 栈的顺序存储和链表存储的差异,答:栈的顺序存储有‘后进先出’的特点，最后进栈的元素必须最先出来，进出栈是有序的，在对编某些需要按顺序操作的程序有很大的作用。

链表存储:通过链表的存储可以实现链表中任意位置的插入元素，删除任意元素，可以实现无序进出。

2. 还会有数据移动吗,为什么,答:栈的顺序存储不会有数据移动，移动的只是指向该数据地址的指针。

堆栈指令程序实验报告

一、实验目的1. 理解堆栈的概念及其在程序中的运用；2. 掌握堆栈指令的汇编语言实现；3. 通过实验加深对堆栈指令的理解和应用。

二、实验环境1. 操作系统：Windows 102. 编译器：MASM 16.13. 汇编语言：x86汇编语言三、实验内容1. 堆栈的概念及特点2. 堆栈指令的汇编语言实现3. 堆栈指令程序的设计与实现4. 实验结果分析四、实验步骤1. 堆栈的概念及特点堆栈是一种先进后出（FILO）的数据结构，它允许程序员在程序中临时存储数据。

堆栈的特点如下：（1）数据结构：堆栈是一种线性表，它具有两个端点，一个用于插入数据（栈顶），一个用于删除数据（栈底）。

（2）操作：堆栈主要有两种操作，即入栈（push）和出栈（pop）。

（3）特点：堆栈的插入和删除操作都在栈顶进行，且遵循先进后出的原则。

2. 堆栈指令的汇编语言实现在x86汇编语言中，堆栈指令主要有以下几种：（1）push：将数据压入堆栈。

语法：push 操作数（2）pop：从堆栈中弹出数据。

语法：pop 操作数（3）pushf：将标志寄存器中的标志位压入堆栈。

语法：pushf（4）popf：从堆栈中弹出标志寄存器中的标志位。

语法：popf3. 堆栈指令程序的设计与实现本实验设计一个简单的堆栈程序，实现以下功能：（1）初始化堆栈；（2）向堆栈中压入数据；（3）从堆栈中弹出数据；（4）清空堆栈；（5）显示堆栈中的数据。

程序如下：```.datastack DWORD 100 DUP(?) ; 定义一个大小为100的堆栈 top DWORD ? ; 定义栈顶指针.codemain PROC; 初始化堆栈mov top, 0mov esp, top; 向堆栈中压入数据 push 10push 20push 30; 从堆栈中弹出数据 pop eaxpush eaxpop eax; 清空堆栈mov esp, top; 显示堆栈中的数据 mov eax, espadd eax, 4mov ecx, 3print_loop:mov edx, [eax] call print_num add eax, 4loop print_loop exitmain ENDP; 打印数字的函数print_num PROC; 将数字转换为字符串; ...retprint_num ENDPEND main```4. 实验结果分析本实验通过汇编语言实现了堆栈的基本操作，包括初始化、压入、弹出、清空和显示堆栈中的数据。

实验周堆栈实验报告

一、实验目的1. 理解堆栈的基本概念和原理。

2. 掌握堆栈的存储结构和操作方法。

3. 熟悉堆栈在程序设计中的应用。

二、实验原理堆栈（Stack）是一种先进后出（FILO）的数据结构，其基本原理是：在堆栈中插入或删除元素时，总是从栈顶开始操作。

堆栈的存储结构可以是数组、链表等。

三、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio 2019四、实验内容与步骤1. 堆栈的定义与初始化首先，我们需要定义一个堆栈的数据结构，包括堆栈的存储空间、最大容量、栈顶指针等。

以下是用C语言定义堆栈的示例代码：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储空间int top; // 栈顶指针} Stack;```然后，初始化堆栈，将栈顶指针置为-1，表示堆栈为空。

```cvoid InitStack(Stack s) {s->top = -1;}```2. 堆栈的入栈操作入栈操作是指在堆栈的栈顶插入一个新元素。

以下是实现入栈操作的代码：```cint IsFull(Stack s) {return s->top == MAX_SIZE - 1;}int Push(Stack s, int element) {if (IsFull(s)) {return 0; // 栈满}s->data[++s->top] = element;return 1;}```3. 堆栈的出栈操作出栈操作是指从堆栈中删除栈顶元素。

以下是实现出栈操作的代码：```cint IsEmpty(Stack s) {return s->top == -1;}int Pop(Stack s, int element) {if (IsEmpty(s)) {return 0; // 栈空}element = s->data[s->top--];return 1;}```4. 堆栈的遍历操作遍历操作是指依次访问堆栈中的所有元素。

堆栈判断回文实验报告

一、实验目的1. 理解堆栈（栈）的基本概念和操作。

2. 掌握利用堆栈判断字符串是否为回文的方法。

3. 提高编程能力，巩固数据结构知识。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理回文是一种正读和反读都相同的字符串。

例如，"madam"、"racecar"等都是回文。

堆栈是一种先进后出的数据结构，利用堆栈可以方便地实现字符串的逆序。

因此，可以通过以下步骤判断一个字符串是否为回文：1. 将字符串的每个字符依次入栈。

2. 将字符串的每个字符依次出栈，并与原字符串进行对比。

3. 如果所有字符都能一一对应，则字符串为回文；否则，不是回文。

四、实验步骤1. 创建一个字符串输入函数，用于从用户处获取字符串。

2. 创建一个堆栈类，包括入栈、出栈、判空、判满等基本操作。

3. 创建一个判断回文的函数，实现上述实验原理。

4. 在主函数中调用输入函数、堆栈类和判断回文函数，输出结果。

五、实验代码```cpp#include <iostream>#include <string>using namespace std;// 堆栈类template <typename T>class Stack {private:T data; // 动态数组int top; // 栈顶指针int maxSize; // 栈的最大容量public:Stack(int size) : maxSize(size), top(-1) { data = new T[maxSize];}~Stack() {delete[] data;}// 入栈操作bool push(T element) {if (top == maxSize - 1) {return false; // 栈满}data[++top] = element;return true;}// 出栈操作bool pop(T &element) {if (top == -1) {return false; // 栈空 }element = data[top--];return true;}// 判空操作bool isEmpty() {return top == -1;}// 判满操作bool isFull() {return top == maxSize - 1; }};// 判断回文函数bool isPalindrome(string str) {Stack<char> stack;int len = str.length();// 将字符串的每个字符入栈for (int i = 0; i < len; i++) {stack.push(str[i]);}// 将字符串的每个字符出栈，并与原字符串进行对比 for (int i = 0; i < len; i++) {char c;if (stack.pop(c)) {if (c != str[i]) {return false; // 字符串不是回文}} else {return false; // 栈空，字符串不是回文 }}return true; // 字符串是回文}int main() {string str;cout << "请输入一个字符串：";getline(cin, str);if (isPalindrome(str)) {cout << "该字符串是回文。

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案

}
/*判队空*/
int QueueEmpty(SeqQueue *sq)
{
if(sq->rear==sq->front)
return 1;
else
return 0;
}
/*循环队列入队*/
void InQueue(SeqQueue *sq,ElemType x)
{
if ((sq->rear+1)%MaxSize==sq->front) /*队满*/
InitStack(s);
printf("(2)栈为%s\n",(StackEmpty(s)?"空":"非空"));
printf("(3)输入要进栈的数据个数：");
scanf("%d",&n);
printf("依次输入进栈的%d个整数：",n);
/*数据依次进栈*/
for(i=0; i<n; i++)
{
printf("循环队列已空，不能进行出队操作！\n");
exit(1);
}
else{
x=sq->data[sq->front];
sq->front=(sq->front+1)%MaxSize;
return x;
}
}
/*取队头元素*/
ElemType GetQueue(SeqQueue *sq)
{
void InitQueue(SeqQueue *sq); /*初始化队列*/
int QueueEmpty(SeqQueue *sq); /*判队空*/

数据结构实验指导书实验二

数据结构实验指导书实验二验实验 2 堆栈与队列（2 学时）实验目的 1．定义顺序栈和链栈的结点类型。

2．掌握栈的插入和删除结点在操作上的特点。

3．熟悉对栈的一些根本操作和具体的函数定义。

4．定义顺序队列和链队列的结点类型。

实验内容堆栈的操作 1．该程序的功能是实现顺序栈的定义和操作。

该程序包括定义的栈结构类型以及对每一种栈操作的具体的函数定义和主函数。

/* 定义 DataType 为 int 类型 */ typedef int DataType; /* 栈的结点类型 */ #define MAXSIZE 1024 typedef struct {DataType data[MAXSIZE]; int top; }SeqStack; /* 初始化顺序栈 */ SeqStack SeqStackInit() /* 检查顺序栈是否为空 */ int SeqStackEmpty(SeqStack S) /* 把 S 置为空栈 */ void ClearStack(SeqStack *S) /* 把元素 x 压入栈，使其成为新的栈顶元素 */ void SeqStackPush(SeqStack *S，DataType x) /* 把栈顶元素弹出 */ DataType SeqStackPop(SeqStack *S) /* 取栈顶元素 */ DataType SeqStackGetTop(SeqStack S) /*输出顺序栈中的元素*/ void SeqStackPrint(SeqStack S) 2．试利用堆栈将队列中的元素逆置。

3．编写括号匹配算法。

* 队列的操作 1. 队列的根本操作：InitQueue(&Q) 构造一个空队列 Q QueueEmpty(Q) 判断队列是否为空 QueueLenght(Q) 返回队列 Q 的元素个数，即队列的长度GetHead(Q，&e) 取队列 Q 的队头元素，并用 e 返回EnQueue(&Q，e) 将元素 e 入队列 DeQueue(&Q，&e) 删除非空队列Q 的队头元素，并用 e 返回其值 2. 队列的表示：队列有两种表示方法：链队列、循环队列（顺序队列）。

堆栈实验报告

堆栈实验报告堆栈实验报告一、引言堆栈（Stack）是一种常见的数据结构，它遵循先进后出（Last-In-First-Out，LIFO）的原则。

在计算机科学中，堆栈常用于函数调用、表达式求值、递归算法等领域。

本实验旨在通过实际操作，深入理解堆栈的定义、特性以及应用。

二、实验目的1. 理解堆栈的概念和特性；2. 掌握堆栈的基本操作：入栈和出栈；3. 实现堆栈的数据结构，并进行相关操作；4. 分析堆栈在实际应用中的作用和意义。

三、实验方法1. 设计堆栈的数据结构：堆栈可以使用数组或链表实现，本实验选择使用数组实现；2. 实现堆栈的基本操作：包括入栈和出栈；3. 编写测试程序：验证堆栈的功能和正确性；4. 进行实验操作：通过不同的测试用例，观察堆栈的行为和变化。

四、实验步骤1. 定义堆栈的数据结构：使用数组作为底层存储结构，同时定义一个指针top 来指示栈顶元素的位置；2. 实现入栈操作：将元素插入栈顶，并更新top指针；3. 实现出栈操作：删除栈顶元素，并更新top指针；4. 编写测试程序：包括对入栈和出栈操作的测试，以及对堆栈的边界条件进行测试；5. 进行实验操作：根据测试程序的结果，观察堆栈的行为和变化。

五、实验结果与分析1. 入栈操作：通过多次入栈操作，观察栈顶元素的变化，验证入栈的正确性；2. 出栈操作：通过多次出栈操作，观察栈顶元素的变化，验证出栈的正确性；3. 边界条件测试：测试空栈的出栈操作，以及满栈的入栈操作，观察程序的响应和错误处理；4. 实验结果分析：根据实验结果，分析堆栈的特性和应用场景，如函数调用、表达式求值等。

六、实验心得通过本次实验，我深入理解了堆栈的概念和特性。

通过实际操作，我掌握了堆栈的基本操作，并成功实现了堆栈的数据结构。

在测试过程中，我发现堆栈在实际应用中具有重要作用，特别是在函数调用和表达式求值等场景下。

堆栈的先进后出特性，可以有效地管理函数调用的上下文和保存临时数据，提高程序的执行效率。

数据结构-堆栈和队列实验报告

数据结构-堆栈和队列实验报告数据结构堆栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的堆栈和队列的基本概念、操作原理以及实际应用。

通过实际编程实现堆栈和队列的相关操作，加深对其特性的认识，提高编程能力和解决问题的能力。

二、实验环境本次实验使用的编程语言为 Python，开发工具为 PyCharm。

三、实验原理（一）堆栈（Stack）堆栈是一种特殊的线性表，其操作遵循“后进先出”（Last In First Out，LIFO）的原则。

可以将堆栈想象成一个只能从一端进行操作的容器，新元素总是被添加到这一端（称为栈顶），而取出元素也只能从栈顶进行。

堆栈的基本操作包括：1、｀push`：将元素压入堆栈。

2、｀pop`：弹出堆栈顶部的元素。

3、｀peek`：查看堆栈顶部的元素，但不弹出。

（二）队列（Queue）队列是另一种特殊的线性表，其操作遵循“先进先出”（First In First Out，FIFO）的原则。

可以将队列想象成一个排队的队伍，新元素在队尾加入，而取出元素从队首进行。

队列的基本操作包括：1、｀enqueue`：将元素加入队列的尾部。

2、｀dequeue`：取出并删除队列头部的元素。

3、｀front`：查看队列头部的元素，但不取出。

四、实验内容（一）堆栈的实现｀｀｀pythonclass Stack:def ＿_init__(self)：selfitems ＝def push(self, item)：selfitemsappend(item)def pop(self)：if not selfis_empty(）：return selfitemspop(）else:return ＂Stack is empty" def peek(self)：if not selfis_empty(）：return selfitems-1else:return ＂Stack is empty" def is_empty(self)：return len(selfitems) ＝＝ 0 def size(self)：return len(selfitems)｀｀｀（二）队列的实现｀｀｀pythonclass Queue:def ＿_init__(self)：selfitems ＝def enqueue(self, item)：selfitemsappend(item)def dequeue(self)：if not selfis_empty(）：return selfitemspop(0) else:return ＂Queue is empty" def front(self)：if not selfis_empty(）：return selfitems0else:return ＂Queue is empty" def is_empty(self)：return len(selfitems) ＝＝ 0 def size(self)：return len(selfitems)｀｀｀（三）应用实例1、利用堆栈实现括号匹配的验证｀｀｀pythondef is_balanced_parentheses(exp)：stack ＝ Stack(）for char in exp:if char in ＇（｛＇：stackpush(char)elif char in ＇）｝＇：if stackis_empty(）：return Falsetop ＝ stackpop(）if （char ＝＝＇）＇ and top!＝＇（＇） or （char ＝＝＇｝＇ and top!＝＇｛＇） or （char ＝＝＇＇ and top!＝＇＇）：return Falsereturn stackis_empty(）｀｀｀2、利用队列实现打印杨辉三角的前 n 行｀｀｀pythondef print_yanghui_triangle(n)：queue ＝ Queue(）queueenqueue(1)print(1)for i in range(1, n)：prev_row ＝for ＿ in range(i ＋ 1)：num ＝ queuedequeue(）prev_rowappend(num)print(num, end=＂＂）if ＿＜ i:new_num ＝ prev_row_ ＋（prev_row_ 1 if ＿＞ 0 else 0) queueenqueue(new_num)print(）｀｀｀五、实验结果与分析（一）堆栈实验结果对于括号匹配的验证，输入`＂（（（）））＂｀，输出为`True`，表示括号匹配正确；输入`＂（（（））＂｀，输出为`False`，表示括号匹配错误。

数据结构实验---堆栈

堆栈模拟队列实验报告

实验报告堆栈操作

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案

北京交通大学-数据结构上机实验-2

堆栈的实验报告

实验二 堆栈和队列基本操作的编程实现

堆栈实验报告

堆栈进制转换实验报告

数据结构堆栈实验报告

堆栈及队列的应用实验原理

栈和队列基本操作实验报告

堆栈指令程序实验报告

实验周堆栈实验报告

堆栈判断回文实验报告

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案

数据结构实验指导书实验二

堆栈实验报告

数据结构-堆栈和队列实验报告

实验二堆栈和队列基本操作的编程实现