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

栈和队列的实验报告

栈和队列的实验报告栈和队列的实验报告引言：栈和队列是计算机科学中常用的数据结构，它们在算法设计和程序开发中起着重要的作用。

本实验旨在通过实际操作和观察，深入理解栈和队列的概念、特点以及它们在实际应用中的作用。

一、栈的实验1.1 栈的定义和特点栈是一种具有特殊操作约束的线性数据结构，它的特点是“先进后出”（Last-In-First-Out，LIFO）。

栈的操作包括入栈（push）和出栈（pop），入栈操作将元素放入栈顶，出栈操作将栈顶元素移除。

1.2 实验步骤在本次实验中，我们使用编程语言实现了一个栈的数据结构，并进行了以下实验步骤：1.2.1 创建一个空栈1.2.2 向栈中依次压入若干元素1.2.3 查看栈顶元素1.2.4 弹出栈顶元素1.2.5 再次查看栈顶元素1.3 实验结果通过实验，我们观察到栈的特点：最后入栈的元素最先出栈。

在实验步骤1.2.2中，我们依次压入了元素A、B和C，栈顶元素为C。

在实验步骤1.2.4中，我们弹出了栈顶元素C，此时栈顶元素变为B。

二、队列的实验2.1 队列的定义和特点队列是一种具有特殊操作约束的线性数据结构，它的特点是“先进先出”（First-In-First-Out，FIFO）。

队列的操作包括入队（enqueue）和出队（dequeue），入队操作将元素放入队尾，出队操作将队头元素移除。

2.2 实验步骤在本次实验中，我们使用编程语言实现了一个队列的数据结构，并进行了以下实验步骤：2.2.1 创建一个空队列2.2.2 向队列中依次插入若干元素2.2.3 查看队头元素2.2.4 删除队头元素2.2.5 再次查看队头元素2.3 实验结果通过实验，我们观察到队列的特点：最先入队的元素最先出队。

在实验步骤2.2.2中，我们依次插入了元素X、Y和Z，队头元素为X。

在实验步骤2.2.4中，我们删除了队头元素X，此时队头元素变为Y。

三、栈和队列的应用栈和队列在实际应用中有广泛的应用场景，下面简要介绍一些常见的应用：3.1 栈的应用3.1.1 表达式求值：通过栈可以实现对表达式的求值，如中缀表达式转换为后缀表达式，并计算结果。

堆栈模拟队列实验报告

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

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

二、实验内容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.掌握使用栈和队列解决实际问题的方法。

二、实验内容1.栈的基本操作实现；2.队列的基本操作实现；3.使用栈和队列解决实际问题。

三、实验原理1.栈的定义和特点：栈是一种具有后进先出(LIFO)特性的线性数据结构，不同于线性表，栈只能在表尾进行插入和删除操作，称为入栈和出栈操作。

2.队列的定义和特点：队列是一种具有先进先出(FIFO)特性的线性数据结构，不同于线性表，队列在表头删除元素，在表尾插入元素，称为出队和入队操作。

3.栈的基本操作：a.初始化：建立一个空栈；b.入栈：将元素插入栈的表尾；c.出栈：删除栈表尾的元素，并返回该元素；d.取栈顶元素：返回栈表尾的元素，不删除。

4.队列的基本操作：a.初始化：建立一个空队列；b.入队：将元素插入队列的表尾；c.出队：删除队列表头的元素，并返回该元素；d.取队头元素：返回队列表头的元素，不删除。

四、实验步骤1.栈的实现：a.使用数组定义栈，设置栈的大小和栈顶指针；b.实现栈的初始化、入栈、出栈和取栈顶元素等操作。

2.队列的实现：a.使用数组定义队列，设置队列的大小、队头和队尾指针；b.实现队列的初始化、入队、出队和取队头元素等操作。

3.使用栈解决实际问题：a.以括号匹配问题为例，判断一个表达式中的括号是否匹配；b.使用栈来实现括号匹配，遍历表达式中的每个字符，遇到左括号入栈，遇到右括号时将栈顶元素出栈，并判断左右括号是否匹配。

4.使用队列解决实际问题：a.以模拟银行排队问题为例，实现一个简单的银行排队系统；b.使用队列来模拟银行排队过程，顾客到达银行时入队，处理完业务后出队，每个顾客的业务处理时间可以随机确定。

五、实验结果与分析1.栈和队列的基本操作实现：a.栈和队列的初始化、入栈/队、出栈/队以及取栈顶/队头元素等操作均能正常运行；b.栈和队列的时间复杂度均为O(1)，操作效率很高。

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

数据结构栈和队列实验报告数据结构栈和队列实验报告1.实验目的本实验旨在通过设计栈和队列的数据结构，加深对栈和队列的理解，并通过实际操作进一步掌握它们的基本操作及应用。

2.实验内容2.1 栈的实现在本实验中，我们将使用数组和链表两种方式实现栈。

我们将分别实现栈的初始化、入栈、出栈、判断栈是否为空以及获取栈顶元素等基本操作。

通过对这些操作的实现，我们可将其用于解决实际问题中。

2.2 队列的实现同样地，我们将使用数组和链表两种方式实现队列。

我们将实现队列的初始化、入队、出队、判断队列是否为空以及获取队头元素等基本操作。

通过对这些操作的实现，我们可进一步了解队列的特性，并掌握队列在实际问题中的应用。

3.实验步骤3.1 栈的实现步骤3.1.1 数组实现栈（详细介绍数组实现栈的具体步骤）3.1.2 链表实现栈（详细介绍链表实现栈的具体步骤）3.2 队列的实现步骤3.2.1 数组实现队列（详细介绍数组实现队列的具体步骤）3.2.2 链表实现队列（详细介绍链表实现队列的具体步骤）4.实验结果与分析4.1 栈实验结果分析（分析使用数组和链表实现栈的优缺点，以及实际应用场景）4.2 队列实验结果分析（分析使用数组和链表实现队列的优缺点，以及实际应用场景）5.实验总结通过本次实验，我们深入了解了栈和队列这两种基本的数据结构，并利用它们解决了一些实际问题。

我们通过对数组和链表两种方式的实现，进一步加深了对栈和队列的理解。

通过实验的操作过程，我们也学会了如何设计和实现基本的数据结构，这对我们在日后的学习和工作中都具有重要意义。

6.附件6.1 源代码（附上栈和队列的实现代码）6.2 实验报告相关数据（附上实验过程中所产生的数据）7.法律名词及注释7.1 栈栈指的是一种存储数据的线性数据结构，具有后进先出(LIFO)的特点。

栈的操作主要包括入栈和出栈。

7.2 队列队列指的是一种存储数据的线性数据结构，具有先进先出(FIFO)的特点。

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

数据结构实验报告之栈和队列1. 编写程序实现顺序栈的各种基本运算：初始化、销毁、清空、判断是否为空栈、求栈的长度、取栈顶元素、进栈、出栈。

在此基础上设计⼀个主程序完成如下功能：（1）初始化栈s；（2）判断栈s是否为空；（3）依次进栈元素a，b，c，d；（4）判断栈s是否为空；（5）输出栈s的长度；（6）栈⾥元素依次出栈,并输出；（7）销毁栈s。

#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef char SElemType;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef struct {SElemType *base; //栈底指针SElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间} SqStack;Status InitStack(SqStack &S) { //构造⼀个空栈SS.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackStatus StackLength(SqStack S) {return S.top - S.base;}//StackLengthStatus DestoryStack(SqStack &S) {S.top = S.base;free(S.base);//若base的值为NULL，则表明栈结构不存在S.base = NULL;S.top = NULL;S.stacksize = 0;return OK;}Status StackEmpty(SqStack S) {if (S.top == S.base)return1;elsereturn0;}//StackEmptyStatus GetTop(SqStack S, SElemType &e) {if (S.top == S.base) return ERROR;e = *(S.top - 1);return OK;}//GetTopStatus Push(SqStack &S, SElemType e) {if (S.top - S.base >= S.stacksize) {S.base = (SElemType*)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(SElemType));if (!S.base)exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize+= STACKINCREMENT;}*S.top++=e;return OK;}//PushStatus Pop(SqStack &S, SElemType &e) {//判断栈是否为空if (S.base == S.top)return ERROR;e = *(S.top - 1);S.top--;return OK;}//Popvoid main(){SqStack s;SElemType e;printf("(1)初始化栈\n");InitStack(s);printf("(2)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(3)依次进栈元素a，b，c，d\n");Push(s, 'a');Push(s, 'b');Push(s, 'c');Push(s, 'd');printf("(4)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(5)The length of the stack is %d\n", StackLength(s));printf("(6)The stack is ");while (!StackEmpty(s)){Pop(s, e);printf("%c \n", e);}printf("(7)销毁栈s");DestoryStack(s);}运⾏结果：2. 编写程序实现链队列的各种基本运算：初始化、销毁、清空、判断是否为空队列、求队列的长度、取队列的头元素、⼊队、出队。

【精品】数据结构栈和队列实验报告

【精品】数据结构栈和队列实验报告实验目的：1.了解栈和队列的概念和基本操作。

2.熟练掌握按顺序存储、链式存储、循环存储结构。

3.掌握栈和队列的应用。

实验环境：操作系统：Windows 7编程软件：Dev-C++实验内容：1.用数组作为栈的存储结构，并以学生管理系统为例，实现“进栈”、“出栈”等基本操作。

先用 typedef struct 学生信息实现一个结构体类型，包含了学号、姓名、性别、出生日期、专业等成员。

typedef struct student{char num[10]; //学号char name[10]; //姓名char sex[2]; //性别int year; //出生年份int major; //专业}StuType;定义一个常量 MAXSIZE 来代表栈的最大空间，建立一个顺序栈。

初始化栈：void init_seqstack(SeqStack &p){p.top = -1;}判断是否为空：进栈操作：bool push_seqstack(SeqStack &p,StuType e){if(p.top==MAXSIZE-1)return 0;p.top++;p.data[p.top]=e;return 1;}定义一个链表结构体类型以存放队列，包含首节点指针和尾结点指针。

typedef struct link_queue{ComType data;struct QueueNode *next;}QueueNode;出队操作：bool de_queue(queue &q,ComType &qdata){QueueNode *p=q.front->next;if(q.front==q.rear)return false;qdata=p->data;q.front->next=p->next;if(q.rear==p)q.rear=q.front;free(p);return true;}实验结果：通过本次实验，我可以熟练掌握栈和队列的基本概念和操作，并能够在相应的程序设计中熟练操作，达到掌握栈和队列的目标。

栈与队列实验报告总结

栈与队列实验报告总结实验报告总结：栈与队列一、实验目的本次实验旨在深入理解栈（Stack）和队列（Queue）这两种基本的数据结构，并掌握其基本操作。

通过实验，我们希望提高自身的编程能力和对数据结构的认识。

二、实验内容1.栈的实现：我们首先使用Python语言实现了一个简单的栈。

栈是一种后进先出（LIFO）的数据结构，支持元素的插入和删除操作。

在本次实验中，我们实现了两个基本的栈操作：push（插入元素）和pop（删除元素）。

2.队列的实现：然后，我们实现了一个简单的队列。

队列是一种先进先出（FIFO）的数据结构，支持元素的插入和删除操作。

在本次实验中，我们实现了两个基本的队列操作：enqueue（在队尾插入元素）和dequeue（从队头删除元素）。

3.栈与队列的应用：最后，我们使用所实现的栈和队列来解决一些实际问题。

例如，我们使用栈来实现一个算术表达式的求值，使用队列来实现一个简单的文本行编辑器。

三、实验过程与问题解决在实现栈和队列的过程中，我们遇到了一些问题。

例如，在实现栈的过程中，我们遇到了一个“空栈”的错误。

经过仔细检查，我们发现是因为在创建栈的过程中没有正确初始化栈的元素列表。

通过添加一个简单的初始化函数，我们解决了这个问题。

在实现队列的过程中，我们遇到了一个“队列溢出”的问题。

这是因为在实现队列时，我们没有考虑到队列的容量限制。

通过添加一个检查队列长度的条件语句，我们避免了这个问题。

四、实验总结与反思通过本次实验，我们对栈和队列这两种基本的数据结构有了更深入的理解。

我们掌握了如何使用Python语言实现这两种数据结构，并了解了它们的基本操作和实际应用。

在实现栈和队列的过程中，我们也学到了很多关于编程的技巧和方法。

例如，如何调试代码、如何设计数据结构、如何优化算法等。

这些技巧和方法将对我们今后的学习和工作产生积极的影响。

然而，在实验过程中我们也发现了一些不足之处。

例如，在实现栈和队列时，我们没有考虑到异常处理和性能优化等方面的问题。

数据结构栈与队列的实验报告

数据结构栈与队列实验报告学院：数学与计算机学院班级：计算机科学与技术姓名：***学号：************实验三栈与队列一、实验目的：（1）熟练掌握栈和队列的结构以及这两种数据结构的特点、栈与队列的基本操作。

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

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

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

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

#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define stack_init_size 100#define stackincrement 10typedef 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)*sizeof(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)return0;e=*--s->top;return e;}int stackempty(sqstack*s){if(s->top==s->base){return1;}else{return0;}}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){case10:printf("A");break;case11: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<stdio.h>#include<string.h>#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;return(TURE);}//出栈int Pop(SeqStack * S,char * x){if(S->top == -1)return(FALSE);else{*x = S->elem[S->top];S->top--;return(TURE);}}//初始化队列void InitQuene(SeqQuene *Q){Q->front = Q->rear = 0;}//入队int EnterQuene(SeqQuene *Q,char x,int cnt) {if((Q->rear+1)%(cnt+1) == Q->front)return(FALSE);Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%(cnt+1);return(TURE);}//出队int DeleteQuene(SeqQuene *Q,char *x,int cnt) {if(Q->front == Q->rear)return(FALSE);*x = Q->element[Q->front];Q->front = (Q->front+1)%(cnt+1);return(TURE);}//主函数void main(){int i,cnt,flag;SeqStack s;SeqQuene q;char a[MAX],b[MAX],c[MAX];flag=0;printf("请输入由*结束且小于%d的回文序列：\n",MAX); for(i = 0;i<MAX+1;i++){scanf("%c",&a[i]);if(a[i] == '*')break;}cnt = i;InitStack(&s);InitQuene(&q);for(i = 0;i<cnt;i++){EnterQuene(&q,a[i],cnt);Push(&s,a[i],cnt);}for(i = 0;i<cnt+1;i++){DeleteQuene(&q,&b[i],cnt);printf("%c",b[i]);}printf("\n");for(i = 0;i<cnt+1;i++){Pop(&s,&c[i]);printf("%c",c[i]);}printf("\n");for(i = 0;i<cnt+1;i++){if(b[i] == c[i])flag = 1;else{flag = 0;break;}}if(flag)printf("Right");elseprintf("Wrong");printf("\n"); }五、运行结果。

数据结构堆栈实验报告

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

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

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

通过编程实现栈和队列的相关操作，加深对其特性的认识，并能够运用栈和队列解决实际问题。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

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

可以将栈想象成一个只有一端开口的容器，元素只能从开口端进出。

入栈操作（Push）将元素添加到栈顶，出栈操作（Pop）则从栈顶移除元素。

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

队列就像是排队买票的队伍，先到的人先接受服务。

入队操作（Enqueue）将元素添加到队列的末尾，出队操作（Dequeue）则从队列的头部移除元素。

四、实验内容（一）栈的实现与操作1、定义一个栈的数据结构，包含栈顶指针、存储元素的数组以及栈的最大容量等成员变量。

2、实现入栈（Push）操作，当栈未满时，将元素添加到栈顶，并更新栈顶指针。

3、实现出栈（Pop）操作，当栈不为空时，取出栈顶元素，并更新栈顶指针。

4、实现获取栈顶元素（Top）操作，返回栈顶元素但不进行出栈操作。

5、实现判断栈是否为空（IsEmpty）和判断栈是否已满（IsFull）的操作。

（二）队列的实现与操作1、定义一个队列的数据结构，包含队头指针、队尾指针、存储元素的数组以及队列的最大容量等成员变量。

2、实现入队（Enqueue）操作，当队列未满时，将元素添加到队尾，并更新队尾指针。

3、实现出队（Dequeue）操作，当队列不为空时，取出队头元素，并更新队头指针。

4、实现获取队头元素（Front）操作，返回队头元素但不进行出队操作。

5、实现判断队列是否为空（IsEmpty）和判断队列是否已满（IsFull）的操作。

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

栈和队列基本操作实验报告实验二堆栈和队列基本操作的编程实现【实验目的】堆栈和队列基本操作的编程实现要求:堆栈和队列基本操作的编程实现(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.实验原理3.1 栈栈是一种特殊的数据结构，它采用“后进先出”的方式对元素进行操作。

栈的主要操作包括入栈和出栈，入栈将元素压入栈顶，出栈将栈顶元素弹出。

3.2 队列队列也是一种特殊的数据结构，它采用“先进先出”的方式对元素进行操作。

队列的主要操作包括入队和出队，入队将元素放入队列尾部，出队将队列头部的元素移除。

4.实验过程4.1 栈的实现a. 定义栈的数据结构在实现栈之前，首先要定义栈的数据结构，包括数据存储结构和相关操作方法。

b. 定义入栈操作入栈操作将元素压入栈顶。

c. 定义出栈操作出栈操作将栈顶元素弹出。

4.2 队列的实现a. 定义队列的数据结构在实现队列之前，首先要定义队列的数据结构，包括数据存储结构和相关操作方法。

b. 定义入队操作入队操作将元素放入队列尾部。

c. 定义出队操作出队操作将队列头部的元素移除。

5.实验结果与分析将栈和队列的数据结构实现后，可以进行测试和验证。

通过将不同类型的元素入栈和入队，然后再进行出栈和出队操作，最后检查栈和队列的状态，验证其正确性。

6.实验总结本实验通过设计和实现栈和队列的数据结构，掌握了栈和队列的基本操作。

并通过对栈和队列的应用，加深了对数据结构的理解和应用。

附件：________无法律名词及注释：________无。

栈和队列实验报告

栈和队列实验报告引言：计算机科学中的数据结构是解决问题的关键。

栈和队列这两种常用的数据结构，无疑在许多实际应用中起着重要的作用。

本篇报告旨在探讨栈和队列的实验结果，并展示它们的实际应用。

一、栈的实验结果及应用1. 栈的实验结果在实验中，我们设计了一个基于栈的简单计算器，用于实现基本的四则运算。

通过栈的先进后出（Last In First Out）特性，我们成功实现了表达式的逆波兰表示法，并进行了正确的计算。

实验结果表明，栈作为一个非常有效的数据结构，可以很好地处理栈内数据的存储和检索。

2. 栈的应用栈在计算机科学中有许多实际应用。

其中之一是程序调用的存储方式。

在程序调用过程中，每个函数的返回地址都可以通过栈来保存和恢复。

另一个应用是浏览器的历史记录。

浏览器中每个访问网页的URL都可以通过栈来存储，以便用户能够追溯他们之前访问的网页。

二、队列的实验结果及应用1. 队列的实验结果在实验中，我们模拟了一个简单的出租车调度系统，利用队列的先进先出（First In First Out）特性实现乘客的排队和叫车。

实验结果表明，队列作为一个具有高效性和可靠性的数据结构，能够很好地处理排队问题。

2. 队列的应用队列在许多方面都有应用。

一个常见的应用是消息队列。

在网络通信中，消息队列可以用于存储和传递信息，确保按照特定的顺序进行处理。

另一个应用是操作系统的进程调度。

操作系统使用队列来管理各个进程的执行顺序，以实现公平和高效的资源分配。

三、栈和队列的比较及选择1. 效率比较栈和队列在实际应用中的效率取决于具体问题的需求。

栈的操作更简单，仅涉及栈顶元素的插入和删除，因此具有更高的执行速度。

而队列涉及到队头和队尾元素的操作，稍复杂一些。

但是，队列在某些问题中的应用更为广泛，例如调度问题和消息传递问题。

2. 如何选择在选择栈和队列时，需要根据实际问题的性质和需求进行综合考虑。

如果问题需要追溯历史记录或按照特定顺序进行处理，则应选择栈作为数据结构。

数据结构堆栈实验报告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-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、掌握堆栈和队列的基本操作。

二、实验原理：1、堆栈的定义：堆栈是一种只允许在表的一端进行插入和删除运算的特殊的线性表。

允许进行插入和删除运算的一端称为栈顶，另一端称为栈底，当链表中没有元素时，称为空栈。

2、堆栈的插入运算称为入栈或者进栈，删除运算称为出栈或者退栈，栈顶的当前位置是动态的，标识栈顶当前位置的指针称为栈顶指针。

每次进栈的数据元素都放在原当前栈顶元素之前成为新的栈顶元素，每次退栈的数据元素都是原当前栈顶元素，最后进入堆栈的数据元素总是最先退出堆栈。

3、堆栈的存储结构：（1）顺序存储结构：栈的顺序存储结构称为顺序栈。

顺序栈的本质是顺序表的简化。

（2）链式存储结构：栈的链式存储结构称为链栈，通常用单链表示。

链栈的插入和删除操作只需处理栈顶的情况。

4、队列的定义：队列是允许在表的一端进行插入，而在表的另一端进行删除的特殊线性表。

允许进行插入的一端称为队尾，允许进行删除的一端称为队头。

队列的插入运算称为进队或者入队，删除运算称为出队或者离队，因此队列又称为先进先出表。

5、队列的存储结构队列的存储结构同线性表一样，可以分为顺序结构和链式结构。

（1）顺序存储结构：用顺序存储结构存储队列称为顺序队列。

顺序队列会出现假溢出问题，解决办法是用首尾相接的书顺序存储结构，称为循环队列。

在队列中，只要涉及队头或者队尾指针的修改都要对其求模。

（2）链式存储结构：用链式存储结构存储的队列称为链队列。

链队列的基本操作的实现基本上也是单链表操作的简化。

通常附设头结点，并设置队头指针指向头结点，队尾指针指向终端结点。

插入数据时只考虑在链队列的尾部进行，删除数据时只考虑在链队列的头部进行。

三、实验内容：1、试编写一个算法，建立一个学生成绩栈，要求从键盘上输入N个整数，按照下列要求分别进入不同的栈。

（1）若输入的整数X小于60，则进入第一个栈；（2）若输入的整数x大于等于60并小于100，则进入第二个栈；（3）若输入的整数x大于100，则进入第三个栈；（4）分别输出每个栈的内容。

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

数据结构栈和队列实验报告实验目的：掌握数据结构栈和队列的基本概念和操作，通过实验加深对栈和队列的理解。

1.实验原理1.1 栈的原理栈是一种具有后进先出(LIFO)特点的数据结构。

在栈中，只允许在栈顶进行插入、删除和访问操作，并且这些操作仅限于栈顶元素。

1.2 队列的原理队列是一种具有先进先出(FIFO)特点的数据结构。

在队列中，元素的插入操作只能在队列的一端进行，称为队尾。

而元素的删除操作只能在队列的另一端进行，称为队头。

2.实验要求2.1 实现栈和队列的基本操作●栈的基本操作：压栈、弹栈、获取栈顶元素和判断栈是否为空。

●队列的基本操作：入队、出队、获取队头元素和判断队列是否为空。

2.2 进行相应操作的测试●对栈进行插入、删除、访问等操作的测试，并输出测试结果。

●对队列进行插入、删除、访问等操作的测试，并输出测试结果。

3.实验环境●操作系统：Windows 10●开发工具：C++编译器4.实验步骤4.1 栈的实现步骤1：定义栈的结构体，包含栈的容量和栈顶指针。

步骤2：根据栈的容量动态分配内存。

步骤3：实现栈的基本操作函数：压栈、弹栈、获取栈顶元素和判断栈是否为空。

步骤4：进行栈的相关测试。

4.2 队列的实现步骤1：定义队列的结构体，包含队列的容量、队头和队尾指针。

步骤2：根据队列的容量动态分配内存。

步骤3：实现队列的基本操作函数：入队、出队、获取队头元素和判断队列是否为空。

步骤4：进行队列的相关测试。

5.实验结果与分析5.1 栈的测试结果●压栈操作测试：将若干元素压入栈中。

●弹栈操作测试：依次弹出栈中的元素。

●获取栈顶元素测试：输出栈顶元素。

●判断栈是否为空测试：输出栈是否为空的结果。

5.2 队列的测试结果●入队操作测试：将若干元素入队。

●出队操作测试：依次出队元素。

●获取队头元素测试：输出队头元素。

●判断队列是否为空测试：输出队列是否为空的结果。

6.结论通过本次实验，我们掌握了栈和队列的基本概念和操作。

数据结构栈和队列实验报告简版

数据结构栈和队列实验报告数据结构栈和队列实验报告1. 实验目的本实验的主要目的是通过实践的方式理解并掌握数据结构中栈和队列的概念、特点和基本操作。

通过实验，我们可以加深对栈和队列的理解，掌握栈和队列的应用方法，并能够设计和实现基于栈和队列的算法。

2. 实验内容本实验分为两个部分：栈的应用和队列的应用。

2.1 栈的应用栈是一种具有特定限制的线性表，它只允许在表的一端进行插入和删除操作，该端被称为栈顶。

栈的特点是“后进先出”（Last In First Out, LIFO），即最后进栈的元素最先出栈。

在本实验中，我们将实现一个简单的栈类，并应用栈来解决一个问题。

假设有一个字符串，其中包含了括号（圆括号、方括号和花括号），我们需要判断该字符串中的括号是否匹配。

为了达到这个目的，我们可以使用栈来辅助实现。

在实现过程中，我们可以定义一个栈来存储左括号，然后依次遍历字符串的每个字符。

当遇到左括号时，将其入栈；当遇到右括号时，判断栈顶是否是对应的左括号，如果是，则将栈顶元素出栈，否则说明括号不匹配。

最后，当栈为空时，表明所有的括号都匹配，否则说明括号不匹配。

2.2 队列的应用队列是一种具有特定限制的线性表，它只允许在表的一端进行插入操作（队尾），在表的另一端进行删除操作（队头）。

队列的特点是“先进先出”（First In First Out, FIFO），即最早进队列的元素最先出队列。

在本实验中，我们将实现一个简单的队列类，并应用队列来解决一个问题。

假设有一群人在排队等候，我们需要按照一定规则进行排队并输出结果。

为了达到这个目的，我们可以使用队列来进行模拟。

在实现过程中，我们可以定义一个队列来存储等候的人，然后依次将人入队列。

当需要输出结果时，我们可以通过队列的出队列操作，按照先后顺序依次输出到达队头的人。

通过使用队列，我们可以模拟人们排队等候的实际情况，并能够按照一定规则输出结果。

3. 实验过程本实验的实验过程如下：1. 首先，我们需要实现一个栈类。

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

数据结构栈和队列实验报告数据结构栈和队列实验报告引言：数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便于程序的运行和管理。

栈和队列是数据结构中最基本的两种形式之一，它们在实际应用中有着广泛的应用。

本实验旨在通过实际操作和观察，深入理解栈和队列的特性和应用。

一、实验目的：1. 了解栈和队列的基本概念和特性；2. 掌握栈和队列的基本操作；3. 理解栈和队列在实际应用中的作用。

二、实验过程：本次实验我们使用Python语言来实现栈和队列的操作。

首先，我们定义了栈和队列的类，并编写了相应的操作方法。

1. 栈的实现：栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的弹簧簿记本。

我们首先定义了一个栈类，其中包括了栈的初始化、入栈、出栈、获取栈顶元素等方法。

通过这些方法，我们可以对栈进行各种操作。

2. 队列的实现：队列是一种先进先出（FIFO）的数据结构，类似于我们日常生活中的排队。

我们同样定义了一个队列类，其中包括了队列的初始化、入队、出队、获取队首元素等方法。

通过这些方法，我们可以对队列进行各种操作。

三、实验结果：我们通过实验，成功实现了栈和队列的基本操作。

在测试过程中，我们发现栈和队列在实际应用中有着广泛的用途。

1. 栈的应用：栈在计算机系统中有着重要的作用，例如在函数调用中，每次函数调用时都会将返回地址和局部变量等信息存储在栈中，以便于函数执行完毕后能够正确返回。

此外，栈还可以用于表达式求值、括号匹配等场景。

2. 队列的应用：队列在操作系统中常用于进程调度，通过维护一个就绪队列，操作系统可以按照一定的策略选择下一个要执行的进程。

此外，队列还可以用于消息传递、缓冲区管理等场景。

四、实验总结：通过本次实验，我们深入了解了栈和队列的特性和应用。

栈和队列作为数据结构中最基本的两种形式，它们在计算机科学中有着广泛的应用。

在实际编程中，我们可以根据具体的需求选择合适的数据结构，以提高程序的效率和可读性。

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

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

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

二、实验环境本次实验使用的编程语言为 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`，表示括号匹配错误。