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

合集下载

栈和队列的实验报告

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

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

一、栈的实验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．熟练掌握链队列和循环队列的基本运算，并特别注意队列满和队列空的判断条件和描述方法；第一节知识准备一、栈：1. 基本概念栈是一种限定仅在表的一端进行插入与删除操作的线性表。

允许进行插入与删除操作的这一端称为栈顶，而另一端称为栈底，不含元素的空表称为空栈，插入与删除分别称进栈与出栈。

由于插入与删除只能在同一端进行，所以较先进入栈的元素，在进行出栈操作时，要比较后才能出栈。

特别是，最先进栈者，最后才能出栈，而最晚进栈者，必最先出栈。

因此，栈也称作后进先出（Last In First Out）的线性表，简称LIFO表。

栈示意图见图3-12. 栈的抽象数据类型定义：ADT Stack{数据对象：D={ | ∈ElemSet, i=1,2,...,n, n>=0}数据关系：R1={< , >| , ∈D, i=2,...,n}基本操作：InitStack(&S) 构造一个空栈SStackEmpty(S) 判断栈S是否为空StackLength(S) 返回栈S的元素个数,即栈的长度GetTop(S,&e) 取栈S的栈顶元素Push(&S,e) 将元素e入栈Pop(&S,&e) 删除S的栈顶元素并用e返回其值（即出栈）}ADT Stack3. 栈的表示：栈有两种存储表示方法：顺序存储结构和链式存储结构。

(1)顺序存储结构：#define STACK_INIT_SIZE 100； //存储空间初始分配量#define STACKINCREMENT 10； //存储空间分配增量typedef struct{SElemType *base； //栈底指针SElemType *top； //栈顶指针int StackSize； //栈的当前容量}SqStack；(2)链式存储结构：Typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode, *LinkList;二、队列：1. 与栈相对应，队列是一种先进先出的线性表。

数据结构实验报告-栈和队列的应用

《数据结构》第五次实验报告学生姓名学生班级学生学号指导老师雷大江重庆邮电大学计算机学院一、实验内容1) 利用栈深度优先进行迷宫求解。

用数组表示迷宫建立栈，利用栈实现深度优先搜索2) 利用队列宽度优先进行迷宫求解。

用数组表示迷宫建立队列，利用队列实现宽度优先搜索二、需求分析利用栈的结构，走过的路入栈，如果不能走出栈，采用遍历法，因此栈内存储的数据就是寻一条路径。

当到达了某点而无路可走时需返回前一点，再从前一点开始向下一个方向继续试探。

因此，压入栈中的不仅是顺序到达的各点的坐标，而且还要有从前一点到达本点的方向，即每走一步栈中记下的内容为(行，列，来的方向)。

三、详细设计（1）基本代码struct item{int x ; //行int y ; //列} ;item move[4] ;（2）代码栈构造函数：void seqstack::Push(int x,int y,int d) //入栈{if(top>=StackSize-1)throw"上溢";top++;data[top].d=d;data[top].x=x;data[top].y=y;}寻找路径：int seqstack::findpath(int a,int b){item move[4]={{0,1},{1,0},{0,-1},{-1,0}};//定义移动结构int x, y, d, i, j ;Push(a,b,-1); //起点坐标入栈while(top!=-1){d=data[top].d+1;x=data[top].x;y=data[top].y;Pop(); //出栈while (d<4) //方向是否可以移动{i=x+move[d].x ; j=y+move[d].y ; //移动后坐标if(Map[i][j]==0) //是否能移动 {Push(x,y,d); //移动前坐标入栈x=i;y=j;Map[x][y]= -1 ;if(x==m&&y==n) //判断是否为终点坐标 {Push(x,y,-1);return 1 ;}else d=0 ;}else d++ ;}}return 0;}（3）伪代码a)栈初始化;b)将入口点坐标及到达该点的方向（设为-1）入栈c)while (栈不空){栈顶元素＝（x , y , d）出栈 ;求出下一个要试探的方向d++ ;while （还有剩余试探方向时）{ if （d方向可走）则 { （x , y , d）入栈 ;求新点坐标 (i, j ) ;将新点（i , j）切换为当前点（x , y） ;if ( (x ,ｙ)= =(ｍ,n) ) 结束 ;else 重置 d=0 ;}else d++ ;}}（4）时间复杂程度时间复杂程度为O（1）2.3 其他在运行时可选择是否自己构造地图，实现函数如下：void creatmap() //自创地图函数{for(int i=1;i<9;i++){for(int j=1;j<9;j++)Map[i][j]=0;}Map[8][9]=1;printmap();cout<<"请设置障碍物位置:（x,y）。

栈与队列的应用

//将 c 置入新的栈顶
}
};
void leave_Car(Parking *pk, Parking *temp, Pavement *pm)
{
//车辆离开停车场
int position, i;
double money1 = 0, money2 = 0;
char num[N];
Car *c1, *c2;
{
cout << "位置" << i << "上停有车牌号为" << q->data->license << "的车辆" << endl;
q = q->next;
i++;
共页/第页
数据结构实验报告
数学与信息科学学院
} } else
cout << "便道里没有车！" << endl; } int main(int argc, char* argv[]) {
共页/第页
数据结构实验报告
数学与信息科学学院
cout << "该车需交费：" << money2 << "元" << endl;
pk->park[pk->top] = NULL;
pk->top--;
while (temp->top >= 0)
{
//辅助栈中有车辆
pk->top++;
pk->park[pk->top] = temp->park[temp->top];

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

数据结构栈与队列的实验报告实验概述本次实验的目的是通过对栈和队列进行实现和应用，加深对数据结构中的栈和队列的理解和巩固操作技能。

栈和队列作为常见的数据结构在程序开发中得到了广泛的应用，本次实验通过 C++ 语言编写程序，实现了栈和队列的基本操作，并对两种数据结构进行了应用。

实验内容1. 栈的实现栈是一种先进后出的数据结构，具有后进先出的特点。

通过使用数组来实现栈，实现入栈、出栈、输出栈顶元素和清空栈等操作。

对于入栈操作，将元素插入到数组的栈顶位置；对于出栈操作，先将数组的栈顶元素弹出，再使其下移，即将后面的元素全部向上移动一个位置；输出栈顶元素则直接输出数组的栈顶元素；清空栈则将栈中所有元素全部清除即可。

3. 栈和队列的应用利用栈和队列实现八皇后问题的求解。

八皇后问题，是指在8×8 的国际象棋盘上放置八个皇后，使得任意两个皇后都不能在同一行、同一列或者同一对角线上。

通过使用栈来保存当前八皇后的位置，逐个放置皇后并检查是否有冲突。

如果当前位置符合要求，则将位置保存到栈中，并继续查询下一个皇后的位置。

通过使用队列来进行八数码问题的求解。

八数码问题，是指在3×3 的矩阵中给出 1 至 8 的数字和一个空格，通过移动数字，最终将其变为 1 2 3 4 5 6 7 8 空的排列。

通过使用队列，从初始状态出发，枚举每种情况，利用队列进行广度遍历，逐一枚举状态转移，找到对应的状态后进行更新，周而复始直到找到正确的答案。

实验结果通过使用 C++ 语言编写程序，实现了栈和队列的基本操作，并对八皇后和八数码问题进行了求解。

程序执行结果如下：栈和队列实现的基本操作都能够正常进行，并且运行效率较高。

栈和队列的实现方便了程序编写并加速了程序运行。

2. 八皇后问题的求解通过使用栈来求解八皇后问题，可以得到一组成立的解集。

图中展示了求解某一种八皇后问题的过程。

从左到右是棋盘的列数，从上到下是棋盘的行数，通过栈的操作，求出了在棋盘上符合不同要求（不在同一行、同一列和斜线上）的八皇后位置。

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

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

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

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

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

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

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

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

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

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

可以使用栈来实现。

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

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

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

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

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

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

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

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

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

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

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

湘潭大学数据结构实验3实验报告源代码栈和队列剖析

“数据结构和算法II”课程实验报告实验名称：栈和队列的综合应用班级姓名学号实验日期：实验机时：2 学时实验成绩：-------------------------------------------------------------------------------一.实验目的：1.熟悉栈的定义和基本操作2.熟悉队列的定义和基本操作3.掌握递归和非递归算法的实现技术和实际应用4.加深对栈结构的理解，培养解决实际问题的编程能力。

二.实验内容：（1）基本实验内容：实现Hanoi 塔的问题；完成迷宫问题或马踏棋盘问题求解。

三.程序及注释：1.Hanoi塔问题：typedef int ElementType;#ifndef _Stack_h#define _Stack_hstruct Node;typedef struct Node *PtrToNode;typedef PtrToNode Stack;int IsEmpty( Stack S );Stack CreateStack( void );void DisposeStack( Stack S );void MakeEmpty( Stack S );void Push( ElementType X, Stack S );ElementType Top( Stack S );void Pop( Stack S );#endif#include <stdio.h>#include <stdlib.h>#define Error( Str ) FatalError( Str )#define FatalError( Str ) fprintf( stderr, "%s\n", Str ), exit( 1 ) #include <stdlib.h>struct Node//定义栈的结构{ElementType Element;PtrToNode Next;char bianhao;};int IsEmpty( Stack S )//判断栈是否为空{return S->Next == NULL;}Stack CreateStack()//创建一个空栈{Stack S;S = malloc( sizeof( struct Node ) );if( S == NULL )FatalError( "Out of space!!!" );S->Next = NULL;MakeEmpty( S );return S;}void MakeEmpty( Stack S )//将栈置空{if( S == NULL )Error( "Must use CreateStack first" );elsewhile( !IsEmpty( S ) )Pop( S );}Void DisposeStack( Stack S )//销毁栈{MakeEmpty( S );free( S );}void Push( ElementType X, Stack S )//向栈S中插入元素n{PtrToNode TmpCell;TmpCell = malloc( sizeof( struct Node ) );if( TmpCell == NULL )FatalError( "Out of space!!!" );else{TmpCell->Element = X;TmpCell->Next = S->Next;S->Next = TmpCell;}}Void Pop( Stack S )//推出栈顶元素{PtrToNode FirstCell;if( IsEmpty( S ) )Error( "Empty stack" );else{FirstCell = S->Next;S->Next = S->Next->Next;free( FirstCell );}}void Move(Stack x,int n,Stack z)//将第编号为n的圆盘从x移动到z{Pop(x);Push(n,z);printf("%2d:将原盘 %d 从 %c 移动到 %c\n",++c,n,x->bianhao,z->bianhao);} void hanoi(int n,Stack x,Stack y,Stack z)//汉诺塔问题解决函数{if (n==1)Move(x,1,z);else{hanoi(n-1,x,z,y);//将编号为1到n-1的圆盘从x利用z移动到yMove(x,n,z);//将编号为n的圆盘从x移动到zhanoi(n-1,y,x,z);}}// 将编号为1到n-1的圆盘从y利用x移动到zint main(){int n,i;Stack x=CreateStack();x->bianhao='x';//对栈x进行编号Stack y=CreateStack();y->bianhao='y';//对栈y进行编号Stack z=CreateStack();z->bianhao='z';//对栈z进行编号printf("请输入Hanoi塔的高度\n");scanf("%d",&n);for(i=n;i>0;i--)Push(i,x);hanoi(n,x,y,z);printf("移动完成！！！");DisposeStack(x);//销毁栈xDisposeStack(y);//销毁栈yDisposeStack(z);//销毁栈z}2.马踏棋盘typedef int ElementType;#ifndef _Stack_h#define _Stack_hstruct Node;typedef struct Node *PtrToNode;typedef PtrToNode Stack;int IsEmpty( Stack S );Stack CreateStack( void );void DisposeStack( Stack S );void MakeEmpty( Stack S );void Push( ElementType X, Stack S );ElementType Top( Stack S );void Pop( Stack S );#include <stdio.h>#include <stdlib.h>#define Error( Str ) FatalError( Str )#define FatalError( Str ) fprintf( stderr, "%s\n", Str ), exit( 1 ) #include <stdlib.h>struct Node//定义栈的结构{ElementType Element;PtrToNode Next;};int IsEmpty( Stack S )//判断栈是否为空{return S->Next == NULL;}Stack CreateStack()//创建一个栈{Stack S;S = malloc( sizeof( struct Node ) );if( S == NULL )FatalError( "Out of space!!!" );S->Next = NULL;MakeEmpty( S );return S;}void MakeEmpty( Stack S )//将栈制空{if( S == NULL )Error( "Must use CreateStack first" );elsewhile( !IsEmpty( S ) )Pop( S );}void DisposeStack( Stack S )//销毁栈{MakeEmpty( S );free( S );}void Push( ElementType X, Stack S )//向栈内输入一个值{PtrToNode TmpCell;TmpCell = malloc( sizeof( struct Node ) );if( TmpCell == NULL )FatalError( "Out of space!!!" );else{TmpCell->Element = X;TmpCell->Next = S->Next;S->Next = TmpCell;}}int e;//用来暂时储存从栈里pop出的元素void Pop( Stack S )//输出栈顶的元素{PtrToNode FirstCell;if( IsEmpty( S ) )Error( "Empty stack" );else{e=S->Next->Element;FirstCell = S->Next;S->Next = S->Next->Next;free( FirstCell );}}void solve(int a,int b,Stack x,Stack y)//棋盘问题函数{int qipan[9][9]={0};qipan[a][b]=1;int i,m,n,step[10][3]={{0,0,0},{1,1,2},{2,1,-2},{3,-1,2},{4,-1,-2},{5,2,1},{6,2,-1},{7,-2,1},{8,-2,-1},{9,0,0}}; //定义棋子行走规则Push(a,x);//向栈x输入起始位置x的值Push(b,y);//向栈y输入起始位置y的值int c[65]={0};//用于储存棋子在每个位置时所选择的路径编号for(i=1;i<3;i++){c[i]++;if(c[i]==9)//如果当前位置的棋子8个路径均不可用，则将当前位置编号置0，从栈x、y中pop出上一步棋子的位置，并设置为当前位置{c[i]=0;i=i-2;qipan[a][b]=0;Pop(x);a=e;Pop(y);b=e;continue;}m=a+step[c[i]][1];n=b+step[c[i]][2];while((!(m>0&&m<9&&n>0&&n<9))||(qipan[m][n]!=0))//当所选路径不合法时，选择下一条路径{c[i]++;//路径编号递增m=a+step[c[i]][1];n=b+step[c[i]][2];if(c[i]==9)//如果当前位置的棋子8个路径均不可用，则将当前位置编号置0，从栈x、y中pop出上一步棋子的位置，并设置为当前位置{qipan[a][b]=0;Pop(x);a=e;Pop(y);b=e;break;}}if(c[i]==9)//若当前棋子无路可走，将路径编号置0后，将位置编号回溯{c[i]=0;i=i-2;continue;}qipan[m][n]=i+1;//若路径可用，将移动后的位置输入栈内，并将当前位置设置为移动后的位置Push(m,x);Push(n,y);a=m;b=n;}int p,q;for(p=1;p<9;p++)//输出解决方案{for(q=1;q<9;q++)printf("%3d",qipan[p][q]);printf("\n");}}int main()//主函数{int a,b;Stack x=CreateStack();Stack y=CreateStack();printf("请输入马的初始位置（x,y），以空格隔开，其中x、y均为1~8区间内的整数\n");scanf("%d%d",&a,&b);solve(a,b,x,y);DisposeStack(x);DisposeStack(y);｝四.运行结果：1.hanoi塔问题：2.马踏棋盘：五.实验心得：在本课程设计中，我明白了理论与实际应用相结合的重要性，并提高了自己组织数据及编写大型程序的能力。

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

数据结构_实验三_栈和队列及其应用(可编辑实验三：栈和队列及其应用1.实验目的：1.1掌握栈和队列的定义与基本操作。

1.2理解栈和队列的应用场景。

1.3熟悉栈和队列在计算机程序设计中的应用。

2.实验内容：2.1实现栈数据结构的基本操作：初始化、入栈、出栈、判断栈空、判断栈满、获取栈顶元素。

2.2实现队列数据结构的基本操作：初始化、入队、出队、判断队空、判断队满、获取队头元素。

2.3利用栈实现表达式求值。

2.4 利用队列解决Josephus问题。

3.实验步骤：3.1栈的实现：栈（Stack）是一种后进先出（LIFO）的数据结构，只能在一端进行插入和删除操作。

栈的实现可以使用数组或链表，这里以数组为例。

1）初始化栈：创建一个数组，设定一个栈指针top，初始时top值为-12）入栈操作：栈不满时，将元素插入到数组的top+1位置，然后top值加13）出栈操作：栈不空时，将数组的top位置的元素删除，然后top 值减14）判断栈空：当栈指针top为-1时，表示栈空。

5）判断栈满：当栈指针top达到数组的最大索引值时，表示栈满。

6）获取栈顶元素：栈不空时，返回数组的top位置的元素。

3.2队列的实现：队列（Queue）是一种先进先出（FIFO）的数据结构，插入操作在队尾进行，删除操作在队头进行。

队列的实现可以使用数组或链表，这里以数组为例。

1）初始化队列：创建一个数组，设定两个指针front和rear，初始时front和rear值均为-12）入队操作：队列不满时，将元素插入到数组的rear+1位置，然后rear值加13）出队操作：队列不空时，将数组的front+1位置的元素删除，然后front值加14）判断队空：当front和rear指针相等且都为-1时，表示队空。

5）判断队满：当rear指针达到数组的最大索引值时，表示队满。

6）获取队头元素：队列不空时，返回数组的front+1位置的元素。

3.3表达式求值：使用栈可以实现对表达式的求值。

实验三栈和队列的应用

实验三栈和队列的应用第一篇：实验三栈和队列的应用一、实验目的掌握栈的数据类型描述及栈的特点；掌握栈的顺序存储结构的特点及算法描述；掌握队列的数据类型描述及链式存储结构的特点和算法描述。

二、实验内容停车场管理。

设有一个可以停放n辆汽车的狭长停车场（先进后出），它只有一个大门可以供车辆进出。

车辆按到达停车场时间的先后依次从停车场最里面向大95E8口处停放（最先到达的第一辆车停放在停车场的最里面）。

如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车离开，则排在便道上的第一辆车就可以进入停车场。

停车场内如有某辆车要离开，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车再按原来的次序进停车场。

每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。

如果停留在便道上的车没进停车场就要离开，允许其离开，不收停车费，并且仍然保持在便道上的车辆次序。

试编程模拟停车场管理。

三、算法描述提示：可以将停车场定义成一个顺序栈s1，便道定义成一个链队列q，而停车场中的某辆车要离开，则在它后面进停车场的车必须让道，让其离开，故还必须有一个临时的顺序栈s2，存放让道的车辆。

当有车辆进停车场时，直接进入s1栈，若s1栈满，则进入便道（链队列q）。

若有s1中车辆x离开时，先让在x后面进栈的车从s1退栈并进栈到s2中，让x离开并收取停车费，然后，再把s2中的所有车辆退栈并重新进入s1栈，最后，将链队列q的队头车辆进栈到s1中并删除队头车辆。

若有链队列q（便道）中的车辆y离开时，从链队列中删除该车辆即可，不收停车费。

车辆的数据可以表示为（车辆编号，到达/离开时间）。

四.程序清单: #include using namespace std;const intStackSize=5;class SeqStack { public:SeqStack(){top=-1;} ~SeqStack(){};void Push(int x);void Push2(int x);int *Return();int Pop(int y);int Count();void PrintStack();private: int data[StackSize];int top;};//入栈void SeqStack::Push(int x){ if(top>=StackSize-1)throw“上溢”;for(int i=0;i<=top+1;i++){if(data[i]==x){cout<<“该车牌已经存在!请重新输入: ”;i=-1;cin>>x;} } top++;data[top]=x;} //返回数组地址int *SeqStack::Return(){ return data;} //临时栈void SeqStack::Push2(int x){ top++;data[top]=x;} //输出函数void SeqStack::PrintStack(){ for(int i=0;i<=top;i++)cout<<“位置为”<int SeqStack::Pop(int y){ if(top==-1)throw“下溢”;int x;x=data[top--];if(y==top+2)data[top+1]=123456789;if(top==-1)data[top+1]=123456789;return x;} //数数int SeqStack::Count(){ return top;}//队列struct Node { int data;Node *next;};class LinkQueue { public: LinkQueue();void EnQueue(int x,int *q);void xzDeQueue(int x);int Count();int DeQueue();private: Node *front,*rear;};//构造函数LinkQueue::LinkQueue(){ Node *s=new Node;s->next=NULL;front=rear=s;} //入队void LinkQueue::EnQueue(int x,int *q){ Node *s=new Node;Node *p=new Node;p=front;while(p){if(p->data ==x){cout<<“便道已有该车牌号,请重新输入: ”;cin>>x;for(int i=0;i<5;i++){if(x==q[i]){cout<<“停车场已有该车牌号,请重新输入: ”;cin>>x;i=-1;}}p=front;} p=p->next;} s->data =x;s->next =NULL;rear->next =s;rear=s;} //出队int LinkQueue::DeQueue(){ if(front==rear)throw“便道无车辆”;Node *p=new Node;int x;p=front->next;x=p->data;front->next =p->next;if(p->next ==NULL)rear=front;delete p;return x;} //计算结点数int LinkQueue::Count(){ Node *p=new Node;p=front;int i=0;while(p&&p->next!=NULL){p=p->next;i++;} return i;} //选择性出队void LinkQueue::xzDeQueue(int x){ if(rear==front)throw“便道无车辆”;Node *p=new Node;p=front;int y;int i=0;for(;p->next!=NULL;p=p->next){if(p->next->data ==x)if(p->next->next!=NULL){Node *q=new Node;q=p->next;y=q->data;p->next =q->next;i=1;delete q;cout<<“车牌号为:”<break;}else{Node *q=new Node;q=p->next;y=q->data;p->next =NULL;i=1;delete q;if(front->next==NULL)rear=front;cout<<“车牌号为:”<break;}} if(i==0)cout<<“无车牌号为:”< SeqStack b;//b是作为临时存放车辆的栈LinkQueue c;//c是作为便道的队列cout<<“tttt1.车辆进入”<cout<<“tttt4.便道车辆离开”<int xh1=1;//xh1为菜单最外层的循环控制变量int time[100];//记录各车辆进入停车场的时间int t1=0;//作为车辆对应的时间编号int money=1;while(xh1==1){cout<<“请选择指令: ”;cin>>zl;switch(zl){case 1:try{int n1=a.Count();int n;cout<<“请输入车牌号: ”;cin>>n;if(n1==4){int *Num=a.Return();for(int i=0;i<=4;i++)if(Num[i]==n){cout<<“停车场已有该车牌号,请重新输入!”; cin>>n;i=-1;}int *CarNum=a.Return();c.EnQueue(n,CarNum);cout<<“停车场已满,请在便道等候!”< break;}a.Push(n);cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”; cin>>time[t1];}t1++;}catch(char*s){cout<break;case 2:try{int n2;//离开车辆的编号cout<<“请输入要离开的车的位置: ”; cin>>n2;if(a.Count()+1==0){cout<<“该停车场没有车辆,请选择其他操作!”; break;}elsewhile(n2<1||n2>a.Count()+1){cout<<“请输入1~”<cin>>n2;}int j=a.Count();for(int i=0;i<(j+1-n2);i++)b.Push2(a.Pop(n2));a.Pop(n2);int j2=b.Count();for(int i1=0;i1<=j2;i1++)a.Push(b.Pop(n2));int j3=c.Count();int time1;cout<<“请输入离开时间: ”;cin>>time1;while(time1<0||time1>23){cout<<“请输入正确的时间(0~23时): ”;cin>>time1;}int day=0;if(time1{cout<<“离开时间已小于进入时间!请加上停留天数(天):”;cin>>day;while(day<=0){cout<<“输入的天数必须大于0：”;cin>>day;}}cout<<“您的费用是(元): ”<<(time1-time[n2-1]+24*day)*money<for(int i2=0;i2<(j+1-n2);i2++)time[n2-1+i2]=time[n2+i2];t1--;if(j3!=0){a.Push(c.DeQueue());cout<<“ttt通知: 便道车辆请进入停车场!”<cout<<“请输入进入时间: ”;cin>>time[t1];while(time[t1]<0||time[t1]>=24){cout<<“请输入正确的时间(0~23时):”;cin>>time[t1];}t1++;}}catch(char *s){cout<break;case 3:a.PrintStack();break;case 4:int n3;cout<<“请输入离开车辆的车牌号: ”;cin>>n3;try{c.xzDeQueue(n3);}catch(char*s){cout<break;case 5:cout<<“请输入单价: ”;cin>>money;cout<<“修改成功!”<cout<<“当前停车场的费用是:”<break;case 6:xh1=0;break;} } system(“pause”);}心得体会:完成时间:2010-10-30第二篇：实验三栈和队列实验报告三栈和队列班级：姓名：学号：专业：一、实验目的：（1）掌握栈的基本操作的实现方法。

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

实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验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();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。

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

数据结构栈与队列实验报告学院：数学与计算机学院班级：计算机科学与技术姓名：***学号：************实验三栈与队列一、实验目的：（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"); }五、运行结果。

《算法与数据结构》实验报告实验3--栈与队列的应用

《算法与数据结构》实验报告姓名学号专业班级计算机类1301实验3栈与队列的应用指导教师实验名称实验目的●了解并掌握栈与队列的概念与定义●能够实现并运用栈与队列●熟练运用栈与队列的基本操作●使用栈实现回溯算法实验环境●个人计算机一台，CPU主频1GHz以上，1GB以上内存，2GB以上硬盘剩余空间。

●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本，英文版)，或VC++ 6.0实验内容1 基本部分(必做)1．链式栈的创建与操作设链式栈中元素的数据类型为整型，编写函数实现以下操作：（1）链式栈的初始化（2）链式栈的输出（从栈顶到栈底）（3）链式栈的判空操作（4）链式栈入栈操作（5）链式栈的出栈操作（6）取栈顶元素的值注：链式栈可不带头节点源代码：ds6.c 2．循环队列的创建与操作设循环队列中元素的数据类型为整型，编写函数实现以下操作：（1）循环队列的初始化（2）循环队列的入栈（3）循环队列的出栈（4）取循环队列的栈顶元素（5）循环队列的输出（从栈顶到栈底）源代码：ds7.c 3．符号平衡问题在语言中往往需要判断一些符号是否是成对出现的，比如{}、[]、()。

如何让判断符号的对称也是很多语言的语法检查的首要任务。

设计一个函数来检查表达式中的符号()、[]、{}是否平衡。

若平衡，返回1；若不平衡返回0。

例如：a(dda){[dfsafd[dfsd]](((fdsd)dfd))dfd}是符号平衡的。

{ad[x(df)ds)]}不是符号平衡的。

源代码：ds8.c实验代码：1.#include<stdio.h>#define MAXSIZE maxlentypedef int elemtype;typedef struct stacknode{elemtype data;struct stacknode *next;}StackNode;typedef struct{StackNode *top;}LinkStack;int *InitStack(LinkStack *S);//初始化链式栈int *Push(LinkStack *S);//入栈函数int *view(LinkStack *S);//输出函数int *Pop(LinkStack *S);//出栈函数int StackTop(LinkStack *S);//取栈顶函数main(){LinkStack *S;int a;char k;S=InitStack(S);if(S->top==NULL){printf("该链式栈为空！");}Push(S);printf("按任意键开始出栈！");getchar();getchar();Pop(S);a=StackTop(S);printf("栈顶元素为%d",a);printf("程序运行完毕,是否重新运行（y/n）：");scanf("%s",&k);if(k=='y'){main();}}int *InitStack(LinkStack *S){S=(LinkStack*)malloc(sizeof(LinkStack));S->top=NULL;return(S);}int *Push(LinkStack *S){int n,i,item;StackNode *p;printf("请输入即将入栈的数据个数：");scanf("%d",&n);for(i=0;i<n;i++){printf("请输入第%d个数：",i+1);scanf("%d",&item);p=(LinkStack*)malloc(sizeof(StackNode));p->data=item;p->next=NULL;p->next=S->top;S->top=p;}view(S);return(S);}int *view(LinkStack *S){StackNode *p;if(S->top==NULL){printf("链式栈为空！");return(0);}else printf("该链式栈从栈顶到栈底数据如下：\n");for(p=S->top;p!=NULL;p=p->next){printf("%d\n",p->data);}}int *Pop(LinkStack *S){StackNode *p;int item;char k;p=S->top;if(S->top==NULL){printf("链式栈为空！");return(0);}else{item=p->data;printf("出栈数据为%d\n",item);S->top=p->next;free(p);view(S);}printf("是否继续出栈（y/n）：");scanf("%s",&k);if(k=='y'){Pop(S);}else return(S);}int StackTop(LinkStack *S){if(S->top==NULL){printf("该链式栈为空！");}return(S->top->data);}2.#include<stdio.h>#define MAXSIZE 30typedef int elemtype;typedef struct{elemtype data[MAXSIZE];int front,rear;}seqqueue;int a=0;//全局变量int InitQueue(seqqueue *Q);//初始化队列函数int view(seqqueue *Q);//输出函数int EnQueue(seqqueue *Q);//入队函数int DeQueue(seqqueue *Q);//出队函数main(){seqqueue *Q;Q=InitQueue(Q);if(Q->front==Q->rear){printf("该队列为空！");}EnQueue(Q);printf("按任意键开始出栈！");getchar();getchar();DeQueue(Q);printf("程序运行完毕,是否重新运行（y/n）："); }int InitQueue(seqqueue *Q){Q=(seqqueue*)malloc(sizeof(seqqueue));Q->front=Q->rear=0;return(Q);}int EnQueue(seqqueue *Q){int n,i,item;printf("请输入即将入队的数据个数：");scanf("%d",&n);if(a>MAXSIZE){printf("该队列已满！");return(0);}else for(i=0;i<n&&a<=30;i++){printf("请输入第%d个数：",i+1);scanf("%d",&item);Q->data[Q->rear]=item;Q->rear=(Q->rear+1)%MAXSIZE;a++;}view(Q);return(Q);}int view(seqqueue *Q){seqqueue *r;int i,j;if(a==0){printf("该队列为空！");return(0);}else printf("该队列从栈顶到栈底数据如下：\n");for(i=0,j=Q->front;i<a;i++,j=(j+1)%MAXSIZE){printf("%d\n",Q->data[j]);}return(Q);}int DeQueue(seqqueue *Q){elemtype item;char k;if(a==0){printf("该队列为空！");return(0);}else{item=Q->data[Q->front];Q->front=(Q->front+1)%MAXSIZE;printf("出队数据为%d\n",item);a--;view(Q);}printf("是否继续出栈（y/n）：");scanf("%s",&k);if(k=='y'){DeQueue(Q);}else return(Q);}3·#include "stdio.h"#include "stdlib.h"#define MAXSIZE 100typedef struct{char data[MAXSIZE];int top;} stack;stack *InitStack(stack *s){s=(stack *)malloc(sizeof(stack));s->top=-1;return s;}int f(stack *s){int i=0,flag=1;char str[MAXSIZE];printf("请输入表达式：");scanf("%s",str);for(i=0;str[i]!='\0';i++){if(str[i]=='('||str[i]=='['||str[i]=='{'){s->top++;s->data[s->top]=str[i];}if(str[i]==')'||str[i]==']'||str[i]=='}'){if(s->top>=0){if(s->data[s->top]==str[i]) s->top--;else{flag=0;break;}}else{flag=0;break;}}}if(s->top!=-1)flag=0;return flag;}int main(){int n;stack *s;s=InitStack(s);n=f(s);if(n==1) printf("表达式中符号平衡\n");else printf("表达式中符号0平衡\n");}使用以上操作，即可完成题目要求。

栈和队列的应用实验报告

栈和队列的应用实验报告栈和队列的应用实验报告引言：栈和队列是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。

本实验报告旨在探讨栈和队列的基本概念、特性以及它们在实际应用中的具体使用。

一、栈的基本概念和特性栈是一种特殊的数据结构，它遵循“先进后出”的原则。

栈有两个基本操作：压栈（push）和弹栈（pop）。

压栈将元素添加到栈的顶部，弹栈则将栈顶元素移除。

栈还具有一个重要的特性，即它的访问方式是受限的，只能访问栈顶元素。

在实际应用中，栈可以用于实现递归算法、表达式求值、括号匹配等。

例如，在递归算法中，当函数调用自身时，需要将当前状态保存到栈中，以便在递归结束后能够恢复到正确的状态。

另外，栈还可以用于实现浏览器的“后退”功能，每次浏览新页面时，将当前页面的URL压入栈中，当用户点击“后退”按钮时，再从栈中弹出最近访问的URL。

二、队列的基本概念和特性队列是另一种常见的数据结构，它遵循“先进先出”的原则。

队列有两个基本操作：入队（enqueue）和出队（dequeue）。

入队将元素添加到队列的尾部，出队则将队列头部的元素移除。

与栈不同的是，队列可以访问头部和尾部的元素。

在实际应用中，队列经常用于任务调度、消息传递等场景。

例如，在操作系统中，任务调度器使用队列来管理待执行的任务，每当一个任务执行完毕后，从队列中取出下一个任务进行执行。

另外，消息队列也是一种常见的应用，它用于在分布式系统中传递消息，保证消息的顺序性和可靠性。

三、栈和队列在实际应用中的具体使用1. 栈的应用栈在计算机科学中有广泛的应用。

其中一个典型的应用是表达式求值。

当计算机遇到一个复杂的表达式时，需要将其转化为逆波兰表达式，然后使用栈来进行求值。

栈的特性使得它非常适合处理这种情况，可以方便地保存运算符和操作数的顺序，并按照正确的顺序进行计算。

另一个常见的应用是括号匹配。

在编程语言中，括号是一种常见的语法结构，需要保证括号的匹配性。

栈和队列实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

国家开放大学《数据结构》课程实验报告(实验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); /*判队空*/

数据结构------栈和队列的应用

/*实验三、四：栈和队列的应用――迷宫问题实验（实验性质：综合性实验）题目：假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为(1，1)，出口坐标为(m，n)，试找出一条从入口通往出口的最短路径。

设计算法并编程输出一条通过迷宫的最短路径或报告一个"无法通过"的信息。

要求：用栈和队列实现，不允许使用递归算法。

注：若改变迷宫形状，可能会出错，有待改进！！！*/#include"stdio.h"#include"stdlib.h"typedef struct //定义栈结构体{int *base;int *top;}sqstack;int mg[10][10];sqstack initstack(sqstack s) //初始化迷宫{s.base=(int*)malloc(sizeof(sqstack));s.top=s.base;return s;}sqstack push(sqstack s,int i,int j) //进栈{int *p=s.top;*p++=i;*p++=j;return s;}sqstack pop(sqstack s) //出栈{s.top=s.top-2;return s;}void print() //打印迷宫{int i,j;for(i=1;i<=10;i++){for(j=1;j<=10;j++){if(mg[i][j]==1) printf("入");if(mg[i][j]==2) printf("出");if(mg[i][j]==11) printf("■");if(mg[i][j]==13) printf("★");else if(mg[i][j]==0||mg[i][j]==14) printf("□");}printf("\n");}printf("\n");}void jmg() //建迷宫{int i,j;for(i=1;i<=10;i++)for(j=1;j<=10;j++)mg[i][j]=0;mg[1][1]=1; //起点mg[10][10]=2; //终点for(i=2,j=2;i<=6;i++) mg[i][j]=11; //11代表墙for(i=4,j=4;i<=8;i++) mg[i][j]=11; //11代表墙for(i=1,j=6;i<=8;i++) mg[i][j]=11; //11代表墙for(i=4,j=8;i<=10;i++) mg[i][j]=11; //11代表墙for(i=1,j=10;i<=9;i++) mg[i][j]=11; //11代表墙for(i=1,j=7;j<=9;j++) mg[i][j]=11; //11代表墙for(i=8,j=2;j<=5;j++) mg[i][j]=11; //11代表墙for(i=10,j=2;j<=8;j++) mg[i][j]=11; //11代表墙printf("\n\n迷宫：\n\n"); //打印迷宫□路通■墙11 ★路13 走过但不通print();}void road(sqstack s) //找路{int i,j,jz;jmg();i=1,j=1;while(i!=10&&j!=10){while(1){if(mg[i][j+1]==0) {jz=1;j=j+1;mg[i][j]=13;push(s,i,j);break;} //右if(mg[i+1][j]==0) {jz=2;i=i+1;mg[i][j]=13;push(s,i,j);break;} //下if(mg[i][j-1]==0) {jz=3;j=j-1;mg[i][j]=13;push(s,i,j);break;} //左if(mg[i-1][j]==0) {jz=4;i=i-1;mg[i][j]=13;push(s,i,j);break;} //上pop(s);mg[i][j]=14; //记住走过的路if(jz==1) j--;if(jz==2) i--;if(jz==3) j++;if(jz==4) i++;}}printf("\n\n迷宫通道★：\n\n"); //打印迷宫□路通■墙11 ★路13 走过但不通print();}void main(){sqstack s;s=initstack(s);road(s);}。

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

允许进行插入与删除操作的这一端称为栈顶，而另一端称为栈底，不含元素的空表称为空栈，插入与删除分别称进栈与出栈。

由于插入与删除只能在同一端进行，所以较先进入栈的元素，在进行出栈操作时，要比较后才能出栈。

特别是，最先进栈者，最后才能出栈，而最晚进栈者，必最先出栈。

因此，栈也称作后进先出（Last In First Out）的线性表，简称LIFO表。

栈示意图见图3-12. 栈的抽象数据类型定义：ADT Stack{数据对象：D={ | ∈ElemSet,i=1,2,...,n, n>=0}数据关系：R1={< , >| , ∈D,i=2,...,n}基本操作：InitStack(&S) 构造一个空栈SStackEmpty(S) 判断栈S是否为空StackLength(S) 返回栈S的元素个数,即栈的长度GetTop(S,&e) 取栈S的栈顶元素Push(&S,e) 将元素e入栈Pop(&S,&e) 删除S的栈顶元素并用e返回其值（即出栈）}ADT Stack3. 栈的表示：栈有两种存储表示方法：顺序存储结构和链式存储结构。