栈与队列实验报告(3)

合集下载

栈和队列的实验报告

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

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

一、栈的实验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.实验内容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)的特点。

数据结构实验三栈和队列的应用

数据结构实验三栈和队列的应用数据结构实验三：栈和队列的应用在计算机科学领域中，数据结构是组织和存储数据的重要方式，而栈和队列作为两种常见的数据结构，具有广泛的应用场景。

本次实验旨在深入探讨栈和队列在实际问题中的应用，加深对它们特性和操作的理解。

一、栈的应用栈是一种“后进先出”（Last In First Out，LIFO）的数据结构。

这意味着最后进入栈的元素将首先被取出。

1、表达式求值在算术表达式的求值过程中，栈发挥着重要作用。

例如，对于表达式“2 ＋ 3 4”，我们可以通过将操作数压入栈，操作符按照优先级进行处理，实现表达式的正确求值。

当遇到数字时，将其压入操作数栈；遇到操作符时，从操作数栈中弹出相应数量的操作数进行计算，将结果压回操作数栈。

最终，操作数栈中的唯一值就是表达式的结果。

2、括号匹配在程序代码中，检查括号是否匹配是常见的任务。

可以使用栈来实现。

遍历输入的字符串，当遇到左括号时，将其压入栈；当遇到右括号时，弹出栈顶元素，如果弹出的左括号与当前右括号类型匹配，则继续，否则表示括号不匹配。

3、函数调用和递归在程序执行过程中，函数的调用和递归都依赖于栈。

当调用一个函数时，当前的执行环境（包括局部变量、返回地址等）被压入栈中。

当函数返回时，从栈中弹出之前保存的环境，继续之前的执行。

递归函数的执行也是通过栈来实现的，每次递归调用都会在栈中保存当前的状态，直到递归结束，依次从栈中恢复状态。

二、队列的应用队列是一种“先进先出”（First In First Out，FIFO）的数据结构。

1、排队系统在现实生活中的各种排队场景，如银行排队、餐厅叫号等，可以用队列来模拟。

新到达的顾客加入队列尾部，服务完成的顾客从队列头部离开。

通过这种方式，保证了先来的顾客先得到服务，体现了公平性。

2、广度优先搜索在图的遍历算法中，广度优先搜索（BreadthFirst Search，BFS）常使用队列。

从起始节点开始，将其放入队列。

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

数据结构实验报告栈和队列
栈（Stack）和队列（Queue）都是常用的数据结构。

它们都是有限的数据存储结构，主要用于记录数据的存储和检索。

它们具有许多相同的特征，可以根据每一个实例的需要而定制遍历，并可以使用相同的存储方法。

但是，从数据操作和操作数据的角度来看，它们仍有差异。

首先，栈和队列的数据操作模式不同。

栈是遵循“先进后出”（LIFO）的原则，只有最后一个元素可以被弹出或者取出；而队列则是遵循“先进先出”（FIFO）的原则，第一个元素是最先被取出或弹出的。

此外，栈不允许插入新元素，而队列允许任何位置插入和删除元素。

此外，栈只能被依次访问，而队列允许改变已有元素的位置。

此外，栈和队列可以用相似的实现方式来构建。

一般来说，它们都使用 .链表，数组或者树来存储数据，并使用相同的Pointers来指向数据结构中的元素。

栈和队列也可以使用交换的方式来改变其存储方式，从而提高其效率。

对于实际应用来说，栈和队列都有自己的优势，具体取决于应用中的需求。

比如，栈通常被用于数据的深度优先遍历，而队列则可以用于数据的广度优先遍历。

此外，栈也可以用于处理函数调用，而队列可以用于处理操作系统任务或者打印池中的任务等。

栈与队列实验报告总结

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验报告——栈和队列的应用

实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求：（1）熟练栈和队列的基本操作；（2）能够利用栈与队列进行简单的应用。

一、题目题目1.利用顺序栈和队列，实现一个栈和一个队列，并利用其判断一个字符串是否是回文。

所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。

例如，a+b&b+a等等。

题目2.假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。

跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。

若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。

现要求写一算法模拟上述舞伴配对问题，并实现。

题目3.打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。

每台打印机具有一个队列（缓冲池），用户提交打印请求被写入到队列尾，当打印机空闲时，系统读取队列中第一个请求，打印并删除之。

请利用队列的先进先出特性，完成打印机网络共享的先来先服务功能。

题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。

试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。

题目5.利用循环链队列求解约瑟夫环问题。

请大家从本组未讨论过的五道题中选择一道，参照清华邓俊辉老师MOOC视频及课本相关知识，编写相应程序。

选择题目3：打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。

二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x）{//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空，新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空，在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令，即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数，将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空，为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。

数据结构_实验三_栈和队列及其应用

数据结构_实验三_栈和队列及其应用实验编号:3 四川师大《数据结构》实验报告 2016年10月29日实验三栈和队列及其应用_一(实验目的及要求(1) 掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们;(2) 本实验训练的要点是“栈”的观点及其典型用法;(3) 掌握问题求解的状态表示及其递归算法，以及由递归程序到非递归程序的转化方法。

二(实验内容(1) 编程实现栈在两种存储结构中的基本操作(栈的初始化、判栈空、入栈、出栈等);(2) 应用栈的基本操作，实现数制转换(任意进制);(3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);(4) 利用栈实现任一个表达式中的语法检查(括号的匹配)。

(5) 利用栈实现表达式的求值。

注:(1),(3)必做，(4),(5)选做。

三(主要仪器设备及软件(1) PC机(2) Dev C++ ,Visual C++, VS2010等四(实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写，请另加附页)(1) 编程实现栈在两种存储结构中的基本操作(栈的初始化、判栈空、入栈、出栈等);A.顺序储存:, 代码部分://Main.cpp:#include"SStack.h"int main(){SqStack S;SElemType e;int elect=1;InitStack(S);cout << "已经创建一个存放字符型的栈" << endl;while (elect){Muse();cin >> elect;cout << endl;switch (elect){case 1:cout << "input data:";cin >> e;Push(S, e);break;case 2:if(Pop(S, e)){cout << e <<" is pop"<< endl; } else{cout<<"blank"<<endl;} break;case 3:if (StackEmpty(S)){cout << "栈空 " << endl;}else{cout << "栈未空 " << endl;}break;case 4:GetTop(S, e);cout << "e is " << e << endl;break;case 5:StackLength(S);break;case 0:break;}}DestroyStack(S);return OK;}//SStack.cpp:#include"SStack.h"//输出菜单void Muse(){cout << "请选择功能:" << endl;cout << " 1.入栈" << endl;cout << " 2.出栈" << endl;cout << " 3.判栈空" << endl;cout << " 4.返回栈顶部数据" << endl; cout << " 5.栈长" << endl;cout << " 0.退出系统" << endl;cout << "你的选择是:" ;}//创建栈Status InitStack(SqStack &S) {S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType)); if (!S.base) exit(ERROR);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//得到顶部数据Status GetTop(SqStack S, SElemType &e) {if (S.base == S.top) return ERROR;e = *(S.top - 1);return OK;}//入栈Status Push(SqStack &S, SElemType &e) {if (S.top - S.base >= STACK_INIT_SIZE){S.base = (SElemType *)realloc(S.base, (STACK_INIT_SIZE + STACKINCREMENT) * sizeof(SElemType));if (!S.base) exit(ERROR);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}//出栈Status Pop(SqStack &S, SElemType &e) { if (S.base == S.top){return ERROR;}e = *--S.top;cout<<"pop succeed"<<endl;return OK;}//判栈空Status StackEmpty(SqStack S) {if (S.top == S.base){return ERROR;}return OK;}//销毁栈Status DestroyStack(SqStack &S){free(S.base);S.top=NULL;S.stacksize = 0;cout << "栈已销毁" << endl;return OK;}int StackLength(SqStack S) {cout << "StackLength is "<<S.top-S.base << endl;return OK;}//SStack.h:#include<iostream> #include<stdlib.h> using namespace std;const int STACK_INIT_SIZE = 100;const int STACKINCREMENT = 10;const int ERROR = 0; const int OK = 1;typedef char SElemType; typedef int Status; typedef struct {SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack(SqStack &S);//创建顺序存储的栈 StatusGetTop(SqStack S, SElemType &e);//得到栈顶数据 Status Push(SqStack &S, SElemType &e);//入栈 Status Pop(SqStack &S, SElemType &e);//出栈 void Muse();//输出菜单界面Status StackEmpty(SqStack S);//判断栈是否为空 StatusDestroyStack(SqStack &S);//销毁栈 int StackLength(SqStack S);//计算栈的长度, 运行结果:B. 链式储存:, 代码部分://Main.cpp#include"Lstack.h" int main(){Lq_Stack L;if(InintStack (L)){cout<<"build stack succeed"<<endl;}else exit (ERROR);int e=0;Menu(L,e);DestroyStack(L);return 0;}//Lstack.cpp#include"Lstack.h" Status InintStack(Lq_Stack &L){ //创建栈L=(LqStack *)malloc(sizeof(LqStack));if(!L) exit(ERROR);L->data=0;L->next=NULL;return OK;}Status push (Lq_Stack &L,SElemType e){//入栈LqStack *p;p=(LqStack *)malloc(sizeof(LqStack));if(!p) exit(ERROR);p->data=e;L->data++;p->next=L->next;L->next=p;return OK;}Status pop (Lq_Stack &L,SElemType &e){ //出栈LqStack *p;if(L->next==NULL) return ERROR;p=L->next;e=p->data;L->next=p->next;L->data--;free(p);return OK;}Status GetTop(Lq_Stack L, SElemType &e){ //得到栈顶数据if(L->next==NULL) return ERROR;e=L->next->data;return OK;}Status StackEmpty(Lq_Stack L){//判断栈是否为空if(L->next==NULL){return ERROR;}else return OK;}int StackLength(Lq_Stack L){//计算栈的长度return L->data;}Status DestroyStack(Lq_Stack &L){//销毁栈LqStack *p;while(!L){L=p;L=L->next;free(p);}return OK;}void Menu(Lq_Stack &L,SElemType e){//输出菜单选择执行的功能int select=1;while(select){cout<<"————————————"<<endl; cout<<"请选择功能"<<endl;cout<<"——————1.入栈"<<endl;cout<<"——————2.出栈"<<endl;cout<<"——————3.得到顶部数据"<<endl;cout<<"——————4.判断栈是否为空"<<endl; cout<<"——————5.输出栈的长度"<<endl; cout<<"——————0.退出程序"<<endl;cout<<"你的选择是:";cin>>select;switch (select){case 0:break;case 1:cout<<"push data:";cin>>e;if(push(L,e)){cout<<"push succeed"<<endl;}else cout<<"push failed"<<endl;break;case 2:if(pop(L,e)){cout<<"data "<<e<<" is pop"<<endl;}else cout<<"pop failed"<<endl;break;case 3:if(GetTop(L,e)){cout<<"head data "<<e<<" is pop"<<endl;} else cout<<"Get failed"<<endl;break;case 4:if(StackEmpty(L)){cout<<"stack is not NULL"<<endl;}else cout<<"stack is NULL"<<endl;break;case 5:cout<<"this stack length is "<<StackLength(L)<<endl;break;}}}//Lstack.h#include<iostream>#include<stdlib.h>using namespace std; const int OK=1;const int ERROR=0;typedef int SElemType; typedef int Status; typedef struct LqStack{ SElemType data;struct LqStack *next; }LqStack,*Lq_Stack;Status InintStack (Lq_Stack &L);//创建栈Status push (Lq_Stack &L,SElemType e);//入栈 Status pop (Lq_Stack&L,SElemType &e);//出栈 Status GetTop(Lq_Stack L, SElemType &e);//得到栈顶数据 Status StackEmpty(Lq_Stack L);//判断栈是否为空int StackLength(Lq_Stack L);//计算栈的长度Status DestroyStack(Lq_Stack &L);//销毁栈void Menu(Lq_Stack &L,SElemType e);//输出菜单选择执行的功能, 运行结果:(2) 应用栈的基本操作，实现数制转换(任意进制);; , 代码部分: //Main.cpp#include"SStack.h"int main(){int number;cout<<"要将数值转换为多少进制 ";cin>>number;conversion(number);return 0;}SStack.cpp#include"SStack.h"Status InitStack(SStack &S){//创建栈S.dase=(ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType)); if (!S.dase) exit(ERROR);S.top=S.dase;S.stacksize=STACK_INIT_SIZE;return OK;}Status push(SStack &S,ElemType e){//入栈if(S.top-S.dase >= S.stacksize){//栈满追加空间S.dase=(ElemType *)realloc(S.dase,(STACK_INIT_SIZE+STACKINCREMENT) * sizeof(ElemType));if(!S.dase) exit(ERROR);S.top=S.dase+STACK_INIT_SIZE;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status pop(SStack &S,ElemType &e){//出栈if(S.top== S.dase) return ERROR; e=*--S.top;return OK;}Status StackEmpty(SStack &S){//判断栈是否为空if(S.dase==S.top) return ERROR; return OK;}void conversion(int number){//转换为e进制并输出SStack S;int N,e;if(InitStack(S)){cout<<"栈创建成功"<<endl;}cout<<"输入待转换的数:";cin>>N;while(N){push(S,N%number);N=N/number;}while(StackEmpty(S)){pop(S,e);cout<<e;}cout<<endl;}//SStack.h#ifndef SSTACK_H#define SSTACK_H#include<iostream> #include<stdlib.h> using namespace std;const int STACK_INIT_SIZE=100;const int STACKINCREMENT=10;const int OK=1;const int ERROR=0;typedef int Status; typedef int ElemType; typedef struct {ElemType *dase;ElemType *top;int stacksize;}SStack;Status InitStack(SStack &S);//创建栈Status push(SStack &S,ElemType e);//入栈 Status push(SStack&S,ElemType &e);//出栈 Status StackEmpty(SStack &S);//判断栈是否为空void conversion(int number);//转换为number进制并输出#endif, 运行结果:(3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列)。

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

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

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

二、实验环境本次实验使用的编程语言为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）的操作。

栈和队列实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(完整版)栈的操作(实验报告)

实验三栈和队列3.1实验目的：（1）熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现；（2）熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。

3.2实验要求：（1）复习课本中有关栈和队列的知识；（2）用C语言完成算法和程序设计并上机调试通过；（3）撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。

3.3基础实验[实验1] 栈的顺序表示和实现实验内容与要求:编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化顺序栈（2）插入元素（3）删除栈顶元素（4）取栈顶元素（5）遍历顺序栈（6）置空顺序栈分析:栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。

对于顺序栈，入栈时，首先判断栈是否为满，栈满的条件为：p->top= =MAXNUM-1，栈满时，不能入栈; 否则出现空间溢出，引起错误，这种现象称为上溢。

出栈和读栈顶元素操作，先判栈是否为空，为空时不能操作，否则产生错误。

通常栈空作为一种控制转移的条件。

注意：（1）顺序栈中元素用向量存放（2）栈底位置是固定不变的，可设置在向量两端的任意一个端点（3）栈顶位置是随着进栈和退栈操作而变化的，用一个整型量top（通常称top为栈顶指针）来指示当前栈顶位置参考程序:#include<stdio.h>#include<stdlib.h>#define MAXNUM 20#define ElemType int/*定义顺序栈的存储结构*/typedef struct{ ElemType stack[MAXNUM];int top;}SqStack;/*初始化顺序栈*/void InitStack(SqStack *p){ if(!p)printf("Eorror");p->top=-1;}/*入栈*/void Push(SqStack *p,ElemType x){ if(p->top<MAXNUM-1){ p->top=p->top+1;p->stack[p->top]=x;}elseprintf("Overflow!\n");}/*出栈*/ElemType Pop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];printf("以前的栈顶数据元素%d已经被删除！\n",p->stack[p->top]);p->top=p->top-1;return(x);}else{ printf("Underflow!\n");return(0);}}/*获取栈顶元素*/ElemType GetTop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];return(x);}else{ printf("Underflow!\n");return(0);}}/*遍历顺序栈*/void OutStack(SqStack *p){ int i;printf("\n");if(p->top<0)printf("这是一个空栈！");printf("\n");for(i=p->top;i>=0;i--)printf("第%d个数据元素是：%6d\n",i,p->stack[i]); }/*置空顺序栈*/void setEmpty(SqStack *p){p->top= -1;}/*主函数*/main(){ SqStack *q;int y,cord;ElemType a;do{printf("\n");printf("第一次使用必须初始化！\n");printf("\n");printf("\n 主菜单\n");printf("\n 1 初始化顺序栈\n");printf("\n 2 插入一个元素\n");printf("\n 3 删除栈顶元素\n");printf("\n 4 取栈顶元素\n");printf("\n 5 置空顺序栈\n");printf("\n 6 结束程序运行\n");printf("\n\n");printf("请输入您的选择( 1, 2, 3, 4, 5,6)");scanf("%d",&cord);printf("\n");switch(cord){ q=(SqStack*)malloc(sizeof(SqStack));InitStack(q);OutStack(q);}break;case 2:{ printf("请输入要插入的数据元素：a=");scanf("%d",&a);Push(q,a);OutStack(q);}break;case 3:{ Pop(q);OutStack(q);}break;case 4:{ y=GetTop(q);printf("\n栈顶元素为：%d\n",y);OutStack(q);}break;case 5:{ setEmpty(q);printf("\n顺序栈被置空！\n");OutStack(q);}break;exit(0);}}while (cord<=6);}[实验2] 栈的链式表示和实现实验内容与要求:编写一个程序实现链栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化链栈（2）链栈置空（3）入栈（4）出栈（5）取栈顶元素（6）遍历链栈分析:链栈是没有附加头结点的运算受限的单链表。

栈和队列的应用实验报告

栈和队列的应用实验报告
《栈和队列的应用实验报告》
一、实验目的
本实验旨在通过实际操作，掌握栈和队列的基本概念、操作及应用，加深对数
据结构的理解和应用能力。

二、实验内容
1. 栈的基本操作：包括入栈、出栈、获取栈顶元素等。

2. 队列的基本操作：包括入队、出队、获取队首元素等。

3. 栈和队列的应用：通过实际案例，探讨栈和队列在实际生活中的应用场景。

三、实验步骤
1. 学习栈和队列的基本概念和操作。

2. 编写栈和队列的基本操作代码，并进行调试验证。

3. 分析并实现栈和队列在实际应用中的案例，如表达式求值、迷宫问题等。

4. 进行实际应用案例的测试和验证。

四、实验结果
1. 成功实现了栈和队列的基本操作，并通过实际案例验证了其正确性和可靠性。

2. 通过栈和队列在实际应用中的案例，加深了对数据结构的理解和应用能力。

五、实验总结
通过本次实验，我深刻理解了栈和队列的基本概念和操作，并掌握了它们在实
际应用中的重要性和作用。

栈和队列作为数据结构中的重要内容，对于解决实
际问题具有重要意义，希望通过不断的实践和学习，能够更加熟练地运用栈和
队列解决实际问题，提高自己的编程能力和应用能力。

六、感想与展望
本次实验让我对栈和队列有了更深入的了解，也让我对数据结构有了更加深刻的认识。

我将继续学习和探索更多的数据结构知识，提高自己的编程能力和解决问题的能力，为将来的学习和工作打下坚实的基础。

同时，我也希望能够将所学知识应用到实际工程中，为社会做出更大的贡献。

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

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

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. 掌握栈和队列的基本操作；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`，表示括号匹配错误。

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

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

2.实验目的本实验的主要目标包括：________●掌握栈和队列的数据结构实现。

●熟悉栈和队列的基本操作：________入栈、出栈、入队、出队。

●理解栈和队列的应用场景，并能够灵活运用。

3.实验原理3.1 栈栈是一种特殊的数据结构，它采用“后进先出”的方式对元素进行操作。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验三栈与队列

实验三栈与队列一、实验目的1．熟练掌握栈和队列的特点2．掌握栈的定义和基本操作，熟练掌握链栈的操作及应用3．掌握对列的定义和基本操作，熟练掌顺序队列的操作及应用, 掌握环形队列的入队和出队等基本操作加深对栈结构和队列结构的理解．逐步培养解决实际问题的编程能力二、实验内容。

1．定义链栈，完成栈的基本操作，测试.2．用栈解决表达式计算问题。

基本要求：操作数为0到9间的整数。

提高要求：操作数为浮点数。

3．根据所给代码求解迷宫问题.基本要求:找到其中一条路径，并输出。

提高要求：找出所有可能的路径,并一一输出.4．定义顺序队列，完成队列的基本操作，测试.5．用队列解决电线布线问题；（起始点0，障碍-2，通路-1）迷宫问题所用数据如下，请在报告中用笔标出找到的路径布线问题所用数据如下，A始点，B是终点，请在报告中用笔标出找到的路径(2,1)(5,3)三、实验环境1．pc机，windows xp操作系统2．VC++6.0软件四、实验步骤实验一：#include<assert.h>#include<iostream>#include"stack"using namespace std;const int maxSize=50;const int stackIncreament=20;template<class T>class Stack{public:Stack(){}virtual bool Push(T& x)=0;virtual bool Pop(T& x)=0;virtual bool getTop(T& x)=0;virtual bool IsEmpty()const=0;virtual bool IsFull()const=0;virtual int getSize()const=0;};template<class T>class SeqStack:public Stack<T>{public:SeqStack(int sz):top(-1),maxSize(sz){elements = new T[maxSize];assert(elements!=NULL);}~SeqStack(){delete []elements;}bool Push(T& x); //入栈bool Pop(T& x); //退栈bool getTop(T& x);bool IsEmpty()const //判断栈空 {return(top==-1)? true:false;}bool IsFull()const //判断栈满 {return(top==maxSize-1)?true:false;}int getSize()const //栈内元素个数{return top+1;}void MakeEmpty() //清空栈内容{top=-1;}void overflowProcess();void show1(SeqStack<T> &s);void show2(SeqStack<T> &s);private:T *elements;int top;int maxSize;};template<class T>void SeqStack<T>::overflowProcess(){T * newArray=new T[maxSize+stackIncreament];if(newArray=NULL){cerr<<"存储分配失败"<<endl;exit(1);}for(int i=0;i<=top;i++)newArray[i]=elements[i];maxSize=maxSize+stackIncreament;delete []elements;elements=newArray;}template<class T> //入栈bool SeqStack<T>::Push(T &x){elements[++top]=x;return true;}template<class T> //出栈bool SeqStack<T>::Pop(T &x){x=elements[top--];return true;}template<class T>bool SeqStack<T>::getTop(T &x){if(IsEmpty()==true)return false;x=elements[top];return true;}template<class T>void SeqStack<T>::show1(SeqStack<T> &s){for(int i=0;i<=s.top;i++)cout<<s.elements[i];cout<<endl;}template<class T>void SeqStack<T>::show2(SeqStack<T> &s){for(int i=s.top;i>=0;i--)cout<<s.elements[i];cout<<endl;}void main(){int a;char s;SeqStack<char> stack(5);cout<<"初始化：maxsize=5"<<endl;cout<<"------------------------------菜单--------------------------------------"<<endl;cout<<"1.判断栈空"<<endl;cout<<"2.入栈"<<endl;cout<<"3.出栈"<<endl;cout<<"4.判断栈满"<<endl;cout<<"5.取栈顶"<<endl;cout<<"6.元素个数"<<endl;cout<<"7.输出栈"<<endl;cout<<"8.连续出栈"<<endl;cout<<"9.退出"<<endl;while(1){cout<<"请输入你的选择：";cin>>a;if(a==9)break;else{switch(a){case 1:{if(stack.IsEmpty())cout<<"栈为空"<<endl;elsecout<<"栈不为空"<<endl;break;}case 2:{if(stack.IsFull()){cout<<"栈满"<<endl;break;}cout<<"入栈:";cin>>s;stack.Push(s);break;}case 3:{if(stack.IsEmpty()){cout<<"栈空"<<endl;break;}cout<<"出栈:";cin>>s;stack.Pop(s);break;}case 4:{if(stack.IsFull())cout<<"栈为满"<<endl;elsecout<<"栈不为满"<<endl;break;}case 5:{cout<<"栈顶为:";stack.getTop(s);cout<<s;cout<<endl;break;}case 6:{cout<<"元素个数为:";cout<<stack.getSize();cout<<endl;break;}case 7:{cout<<"输出栈:";stack.show1(stack);break;}case 8:{cout<<"连续出栈:";stack.show2(stack);break;}}}}}实验二：#include<assert.h>#include<iostream>#include<fstream>#include<math.h>#include<stack>#include<string>using namespace std;const int maxSize=50;const int stackIncreament=20;class Calculator{public:Calculator(){};void Run(string out);void Clear();void print();int isp(char ch);int icp(char ch);bool isdigit(char ch);string postfix(string in);private:stack<double> s;stack<int>d;void AddOperand(double value);bool get2Operands(double& left,double& right); void DoOperator(char op);};int Calculator::isp(char ch){switch(ch){case'#':return 0;break;case'(':return 1;break;case'*':case'/':case'%':return 5;break;case'+':case'-':return 3;break;case')':return 6;break;}}int Calculator::icp(char ch){switch(ch){case'#':return 0;break;case'(':return 6;break;case'*':case'/':case'%':return 4;break;case'+':case'-':return 2;break;case')':return 1;break;}}bool Calculator::isdigit(char ch){if(ch>='0'&&ch<='9')return true;elsereturn false;}string Calculator::postfix(string in) {stack<char> s;char ch='#',ch1,op;string out;s.push(ch); //输入流要构造 for(int i=0;;){ch=in.at(i);if(isdigit(ch)){out+=ch;i++;}else{ch1=s.top();if(isp(ch1)<icp(ch)){s.push(ch);i++;}else if(isp(ch1)>icp(ch)){op=s.top();s.pop();out+=op;}else{op=s.top();s.pop();if(op=='(')i++;}}if(s.empty()&&ch=='#')break;}cout<<out;return out;}void Calculator::DoOperator(char op) {double left,right,value;bool result;result=get2Operands(left,right);if(result==true)switch(op){case'+':value=left+right;d.push(value);break;case'-':v alue=left-right;d.push(value);break;case'*':value=left*right;d.push(value);break;case'/':if(right==0.0){cerr<<"Divide by 0!"<<endl;Clear();}else{value=left/right;d.push(value);}break;}elseClear();}bool Calculator::get2Operands(double& left,double& right) {if(d.empty()==true){cerr<<"缺少右操作数！"<<endl;return false;}right=d.top();d.pop();if(d.empty()==true){cerr<<"缺少左操作数！"<<endl;return false;}left=d.top();d.pop();return true;}void Calculator::AddOperand(double value) {s.push(value);}void Calculator::Run(string out){char ch;for(int i=0;i<out.size();i++){ch=out.at(i);switch(ch){case'+':case'-':case'*':case'/':DoOperator(ch);break;default:int ch_=ch-48;d.push(ch_);}}}void Calculator::Clear(){while(!s.empty())s.pop();}void Calculator::print(){ i nt t;t=d.top();cout<<t<<endl;Clear();}void main(){string in,out;cin>>in;Calculator c;out=c.postfix(in);c.Run(out);cout<<endl;c.print();}实验三：#include<iostream>#include<stack>#include<string>using namespace std;const int m=7;const int p=7;int maze[m+2][p+2];int mark[m+2][p+2];struct offsets{int a,b;char* dir;}move[8]={{-1,0,"N"},{-1,1,"NE"},{0,1,"E"},{1,1,"SE"},{1,0,"S"} ,{1,-1,"SW"},{0,-1,"W"},{-1,-1,"NW"}};struct items{int x,y,dir;}item[(m+2)*(p+2)];void show(stack<items> &st){items it;for(;;){it=st.top();cout<<it.x<<" "<<it.y<<" "<<move[it.dir].dir<<endl;st.pop();if(st.empty())return;}}int path(int n,int q) //迷宫算法{int i,j,d,g,h;for(i=0;i<p+2;i++)maze[i][0]=maze[i][p+1]=maze[0][i]=maze[m+1][i]=1;maze[1][1]=0;maze[1][2]=1;maze[1][3]=1;maze[1][4]=0;maze[1][5]= 0;maze[1][6]=0;maze[1][7]=0;maze[2][1]=0;maze[2][2]=0;maze[2][3]=1;maze[2][4]=1;maze[2][5]= 0;maze[2][6]=0;maze[2][7]=0;maze[3][1]=1;maze[3][2]=0;maze[3][3]=0;maze[3][4]=0;maze[3][5] =1;maze[3][6]=0;maze[3][7]=0;maze[4][1]=0;maze[4][2]=0;maze[4][3]=0;maze[4][4]=1;maze[4][5] =1;maze[4][6]=0;maze[4][7]=1;maze[5][1]=1;maze[5][2]=0;maze[5][3]=0;maze[5][4]=0;maze[5][5] =1;maze[5][6]=0;maze[5][7]=1;maze[6][1]=1;maze[6][2]=1;maze[6][3]=1;maze[6][4]=0;maze[6][5] =0;maze[6][6]=0;maze[6][7]=0;maze[7][1]=1;maze[7][2]=1;maze[7][3]=1;maze[7][4]=1;maze[7][5] =1;maze[7][6]=0;maze[7][7]=0;for(i=0;i<p+2;i++){for(j=0;j<p+2;j++)cout<<maze[i][j]<<" ";cout<<endl;}for(i=0;i<m+2;i++)for(j=0;j<p+2;j++)mark[i][j]=0;mark[1][1]=1;stack<items> st;items tmp;tmp.x=1;tmp.y=0;tmp.dir=2;st.push(tmp);while(!st.empty()){ tmp=st.top();st.pop();i=tmp.x;j=tmp.y;d=tmp.dir;while(d<8){g=i+move[d].a;h=j+move[d].b;if(g==n&&h==q){show(st);cout<<n<<" "<<q<<endl;return 1;}if(maze[g][h]==0&&mark[g][h]==0){mark[g][h]=1;tmp.x=i;tmp.y=j;tmp.dir=d;st.push(tmp);i=g;j=h;d=0;}elsed++;}}cout<<"no path in maze"<<endl;return 0;}void main(){path(3,7);}实验四：#include<iostream.h>template<class T>class arrqueue{private:char msize;char front;char rear; T *qu;public:arrqueue(char size);~arrqueue();void clear();bool enqueue(const T item);bool dequeue(T&item);bool getfront(T&item);void print();};template<class T>arrqueue<T>::arrqueue(char size) { msize=size+1;qu=new T[msize];front=rear=0;}template<class T>arrqueue<T>::~arrqueue() {delete[] qu; }template<class T>void arrqueue<T>::clear() {front=rear; }template<class T>bool arrqueue<T>::enqueue(const T item) { if(((rear+1)%msize)==front) {cout<<"队列已满"<<endl; return false;} qu[rear]=item;rear=(rear+1)%msize;return true; }template<class T>bool arrqueue<T>::dequeue(T&item) {if(front==rear) {cout<<"队列为空"<<endl;return false;}item=qu[front];front=(front+1)%msize;return true;}template<class T>bool arrqueue<T>::getfront(T&item) {if(front==rear){cout<<"队列为空"<<endl;return false;}item=qu[front];return true;}template<class T>void arrqueue<T>::print() {cout<<qu[front]<<'\t';}void main(){arrqueue<char> a(5);char i,b[10],p,q;cout<<"队空！"<<endl;cout<<"入队：";for(i=0;i<=5;i++) {cin>>b[i];a.enqueue(b[i]);}cout<<"溢出 F"<<endl;cout<<"取队头 ";a.getfront(q);cout<<q<<endl;cout<<"元素个数 4"<<endl;/*a.dequeue(p);a.print();cout<<p<<endl;*/}实验五：#include<assert.h>#include<iostream>#include<queue>using namespace std;const int m=7;const int p=7;int grid[m+2][p+2];struct Position{int row,col;};bool FindPath(Position start,Position finish,int& PathLen,Position *& path){if(start.row==finish.row&&start.col==finish.col){PathLen=0;return true;}int NumOfNbrs=4,i,j;for(i=0;i<=m+1;i++)grid[0][i]=grid[m+1][i]=grid[i][0]=grid[i][m+1]=-1;grid[1][1]= 0;grid[1][2]= 0;grid[1][3]=-1;grid[1][4]= 0;grid[1][5]= 0;grid[1][6]= 0;grid[1][7]= 0;grid[2][1]= 0;grid[2][2]= 0;grid[2][3]=-1;grid[2][4]=-1;grid[2][5]= 0;grid[2][6]= 0;grid[2][7]= 0;grid[3][1]= 0;grid[3][2]= 0;grid[3][3]= 0;grid[3][4]= 0;grid[3][5]=-1;grid[3][6]= 0;grid[3][7]= 0;grid[4][1]= 0;grid[4][2]= 0;grid[4][3]= 0;grid[4][4]=-1;grid[4][5]=-1;grid[4][6]= 0;grid[4][7]= 0;grid[5][1]=-1;grid[5][2]= 0;grid[5][3]= 0;grid[5][4]= 0;grid[5][5]=-1;grid[5][6]= 0;grid[5][7]= 0;grid[6][1]=-1;grid[6][2]=-1;grid[6][3]=-1;grid[6][4]=0;grid[6][5]= 0;grid[6][6]= 0;grid[6][7]= 0;grid[7][1]=-1;grid[7][2]=-1;grid[7][3]=-1;grid[7][4]=0;grid[7][5]= 0;grid[7][6]= 0;grid[7][7]= 0;for(i=0;i<m+2;i++){for(j=0;j<p+2;j++)cout<<grid[i][j]<<'\t';cout<<endl;}Position offset[4];offset[0].row=0; offset[0].col=1;offset[1].row=1; offset[1].col=0;offset[2].row=0; offset[2].col=-1;offset[3].row=-1; offset[3].col=0;Position here,nbr;here.row=start.row; here.col=start.col;grid[start.row][start.col]=0;queue<Position> Q;cout<<endl;cout<<endl;cout<<"路径坐标顺序："<<endl;do{for(i=0;i<NumOfNbrs;i++){nbr.row=here.row+offset[i].row;nbr.col=here.col+offset[i].col;if(grid[nbr.row][nbr.col]==0){grid[nbr.row][nbr.col]=grid[here.row][here.col]+1; // cout<<nbr.row<<" "<<nbr.col<<endl;if(nbr.row==finish.row&&nbr.col==finish.col){break;}Q.push(nbr);}}if(nbr.row==finish.row&&nbr.col==finish.col){break;}if(Q.empty()){cout<<"no path"<<endl;return false;}here=Q.front();Q.pop ();}while(true);PathLen=grid[finish.row][finish.col];path=new Position[PathLen];here=finish;for(j=PathLen-1;j>=0;j--){path[j]=here;for(i=0;i<NumOfNbrs;i++){nbr.row=here.row+offset[i].row;nbr.col=here.col+offset[i].col;if(grid[nbr.row][nbr.col]==j){cout<<nbr.row<<" "<<nbr.col<<endl;break;}}here=nbr;}return true;}void main(){int pl=0;Position st,fi,*p;st.row=3;st.col=2;fi.row=4;fi.col=6;FindPath(st,fi,pl,p);}五、实验结果与讨论1．如何计算顺序循环队列中元素的个数？2．如果对前面所讨论的顺序循环队列采用设置运算标志的方法来区分队列的满和空的状态，试给出对应的各运算的关键代码？3.栈的存取特点适合于什么样的应用？。

实验三栈和队列

实验三栈和队列第一篇：实验三栈和队列实验报告三栈和队列班级：姓名：学号：专业：一、实验目的：（1）掌握栈的基本操作的实现方法。

（2）利用栈先进后出的特点，解决一些实际问题。

（3）掌握链式队列及循环队列的基本操作算法。

（4）应用队列先进先出的特点，解决一些实际问题。

二、实验内容：1、使用一个栈，将一个十进制转换成二进制。

粘贴源程序：package Word1;public class Node {} T data;Node next;public Node(T a){ } public Node(T a,Node n){} this.data=a;this.next=n;this(a,null);-----package Word1;public class Stack {} public Node Top;public Stack(){ } public void push(T a){ } public T Out(){}T a=this.Top.data;this.T op=this.Top.next;return a;this.Top=new Node(a,this.T op);this.T op=null;--package Word1;import java.util.*;public class Test {} static Scanner scan=new Scanner(System.in);static int temp=0;static int a=0;static Stack s=new Stack();public static void main(String[] args){} temp=scan.nextInt();while(true){} while(s.Top!=null){}System.out.printf(“%d”,s.Out());a=temp%2;s.push(a);temp=te mp/2;if(temp==0)break;粘贴测试数据及运行结果：2、回文是指正读反读均相同的字符序列，如“acdca”、“dceecd”均是回文，但“book”不是回文。

实验3 栈和队列

实验3 栈和队列一实验目的1、掌握栈和队列的概念及其特点；2、掌握栈和队列基本运算的算法并能设计程序实现；3、理解栈和队列的典型应用；二实验原理队列是运算受限的线性表，具有先进先出的特点。

队列的应用十分广泛，凡是具有先进先出特点需要排队处理的问题都可以使用队列来解决，比如操作系统中的I/O缓冲区管理，优先队列等等。

三使用仪器，材料1 计算机2 Wndows xp3 VC6.0四实验步骤模拟银行的叫号机。

在程序运行过程中使用文本菜单供用户选择，选择1则模拟储户按下叫号机取叫号纸（即入队列），选择2则模拟银行工作人员按下叫号机，请取得相应号数的储户到前台办理业务（即出队列）。

叫号机的号数从1号开始往上递增。

五实验过程原始记录1 基本数据结构描述；2 函数间的调用关系；3 用类C语言描述各个子函数的算法；附录：源程序。

#include <iostream.h>#include <process.h>#include <stdlib.h>#define OK 1#define ERROR -1#define OVERFLOW 0 typedef int qelemtype;typedef int status;typedef struct qnode{qelemtype data;struct qnode *next;}qnode,*queueptr;typedef struct{queueptr front;queueptr rear;}linkqueue;status initqueue(linkqueue &q) {q.front=q.rear=new qnode;if (!q.front)exit(OVERFLOW);q.front->next=NULL;return OK;};status enqueue(linkqueue &q) {queueptr p;p=new qnode;if(!p) exit(OVERFLOW);if(q.front==q.rear){ q.rear->data=1;}p->data=q.rear->data+1;p->next=NULL;q.rear->next=p;q.rear=p;return OK; }void gethead( linkqueue &q){ queueptr p;if(q.front->next==NULL){ cout<<"已没有客户需要办理业务"<<endl;}else{cout<<"请"<<q.front->data<<"号到前台办理业务"<<endl;p=q.front->next;q.front=p;}}void main(){ int a ;char cont='y';linkqueue q;initqueue(q);while(cont=='y'){ cout<<"请输入操作序号"<<endl;cout<<"1：取号"<<endl;cout<<"2：请取号人到前台办理业务"<<endl;cin>>a;switch(a){case 1:enqueue(q);break;case 2:gethead(q);break; }cout<<"是否继续操作？（y or n）";cin>>cont;if(cont=='y') cont='y';}}六试验结果分析将实验结果分析、实验中遇到的问题和解决问题的方法以及关于本实验项目的心得体会，写在实验报告上。

栈与队列实验报告(3)

栈和队列的实验报告

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

数据结构实验三栈和队列的应用

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

栈与队列实验报告总结

实验报告——栈和队列的应用

数据结构_实验三_栈和队列及其应用

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

栈和队列实验报告

(完整版)栈的操作(实验报告)

栈和队列的应用实验报告

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

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

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

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

实验三 栈与队列

实验三栈和队列

实验3 栈和队列

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

实验三栈与队列