实验三 栈和队列

合集下载

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

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

数据结构栈和队列实验报告数据结构栈和队列实验报告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):栈是一种后进先出(Last In First Out,LIFO)的数据结构,即最后一个进入栈的元素总是第一个出栈。

在计算机程序中,栈常常被用来实现函数调用和递归等操作。

队列(Queue):队列是一种先进先出(First In First Out,FIFO)的数据结构,即第一个进入队列的元素总是第一个出队。

在计算机程序中,队列常常被用来实现任务的调度和缓冲等操作。

三、实验步骤与结果创建一个空栈和一个空队列。

对栈进行入栈(push)和出栈(pop)操作,观察并记录结果。

可以发现,栈的出栈顺序与入栈顺序相反,体现了后进先出的特性。

对队列进行入队(enqueue)和出队(dequeue)操作,观察并记录结果。

可以发现,队列的出队顺序与入队顺序相同,体现了先进先出的特性。

尝试在栈和队列中查找元素,记录查找效率和准确性。

由于栈和队列的特性,查找操作并不像在其他数据结构(如二叉搜索树或哈希表)中那样高效。

四、实验总结与讨论通过本次实验,我更深入地理解了栈和队列这两种数据结构的基本特性和操作。

在实际编程中,我可以根据需求选择合适的数据结构来提高程序的效率。

我注意到,虽然栈和队列在某些操作上可能不如其他数据结构高效(如查找),但它们在某些特定场景下具有无可替代的优势。

例如,在实现函数调用和递归时,栈的特性使得它成为最自然的选择;在实现任务调度和缓冲时,队列的特性使得它成为最佳选择。

我也认识到,不同的数据结构适用于解决不同的问题。

在选择数据结构时,我需要考虑数据的特性、操作的频率以及对时间和空间复杂度的需求等因素。

通过实际操作,我对栈和队列的实现方式有了更深入的理解。

例如,我了解到栈可以通过数组或链表来实现,而队列则可以通过链表或循环数组来实现。

实验三 栈和队列

实验三 栈和队列

实验三栈和队列的操作一、实验学时 2学时二、背景知识1.栈:(1).入栈和进栈操作只能从栈顶一端进行;(2).LIFO(后进先出);(3).栈的两种存储定义:顺序栈和链式栈。

2.队列:(1).入队操作从队尾进行,出队操作从对头进行;(2).FIFO(先进先出);(3).队列的两种存储定义:顺序队和链队。

三、目的要求1.掌握栈的顺序表示和实现。

Typedef struct{SelemType *base;SelemType *base;Int stacksize;}sqstack;2.掌握队列的链式表示和实现以及顺序表示和实现。

链队列:Typedef struct Qnode{QelemType data;struct Qnode *next;} Qnode,*Queueptr;Typedef struct{Queueptr front;Queueptr rear;}linkQueue;顺序队列:#define MAXQSIZE 100Typedef struct{Qelemtype *base;int front;int rear;}sqQueue;四、实验内容1.顺序栈和循环队列的创建、入栈(队)、出栈(队)等基本操作。

2.数制转换问题【问题描述】十进制数N和其它d进制数的转换是计算机实现计算的基本问题。

试编制一段程序满足下列要求:对于输入的任意一个非负十进制整数,打印输出与其等值的八进制数。

【基本要求】首先初始化一个顺序栈,通过入栈出栈操作辅助完成数制的转换操作。

五、程序实例:顺序队列的入队和出队操作。

【问题描述】使有数组创建队列。

程序使有选项运行队列的操作,如:输入1表示元素入队,输入2表示元素出队,输入3表示结束程序运行,并且将队列剩余元素输出。

【基本要求】首先使有数组创建队列,然后编写入队函数和出队函数,最后编写主函数。

【测试数据】如:输入队列的元素是:[2][3][4][5][6]取出队列的元素是:[2]剩余队列的元素是:[3][4][5][6]【实现提示】#define MAXQUEUE 10 /* 队列的最大容量 */int queue[MAXQUEUE]; /* 队列的数组定义 */int front = -1; /* 队头 */int rear = -1; /* 队尾 *//*―――――――――――入队―――――――――――*/int enqueue(int value){if ( rear >= MAXQUEUE ) /* 检查队列是否全满 */return -1; /* 无法存入 */rear++; /* 队尾指针前移 */queue[rear] = value; /* 存入队列 */}/*―――――――――――出队―――――――――――*/int dequeue(){if ( front == rear ) /* 检查队列是否为空 */return -1; /* 无法取出 */front++; /* 队头指针前移 */return queue[front]; /* 队列取出 */}。

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

湘潭大学数据结构实验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表达式求值:使用栈可以实现对表达式的求值。

栈与队列实验报告总结

栈与队列实验报告总结

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

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

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

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

在本次实验中,我们实现了两个基本的栈操作:push(插入元素)和pop(删除元素)。

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

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

在本次实验中,我们实现了两个基本的队列操作:enqueue(在队尾插入元素)和dequeue(从队头删除元素)。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验三 栈和队列

实验三 栈和队列

实验报告三栈和队列一、实验目的:(1)掌握栈的基本操作的实现方法。

(2)利用栈先进后出的特点,解决一些实际问题。

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

(4)应用队列先进先出的特点,解决一些实际问题。

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

粘贴源程序:package Q1;public class SeqStack {public int element[];public int top;public static SeqStack p;public SeqStack(int size){this.element=new int[size];this.top=-1;}public void push(int x){this.top++;this.element[this.top]=x;}public int pop(){return this.top==-1 ? -1: (int)this.element[this.top--];}public int get(){return this.top==-1 ? -1: (int)this.element[this.top];}public static void disp(SeqStack p){int t = -2;while(t!=-1){t=p.pop();if(t!=-1)System.out.printf("%d",t);}}public static void fun(int x){int t;while(x!=1){t=x%2;x=x/2;p.push(t);}if(x==1)p.push(x);}public static void main(String args[]){p=new SeqStack(13);fun(99);disp(p);}}粘贴测试数据及运行结果:2、回文是指正读反读均相同的字符序列,如“acdca”、“dceecd”均是回文,但“book”不是回文。

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

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

实验报告——栈和队列的应用第一篇:实验报告——栈和队列的应用实验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"); }五、运行结果。

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

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

数据结构栈和队列实验报告数据结构栈和队列实验报告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. 如何选择在选择栈和队列时,需要根据实际问题的性质和需求进行综合考虑。

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

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

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

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

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

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

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. 队列的应用:队列在操作系统中常用于进程调度,通过维护一个就绪队列,操作系统可以按照一定的策略选择下一个要执行的进程。

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

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

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

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

栈和队列的操作实训心得

栈和队列的操作实训心得

栈和队列的操作实训心得好呀,让我来写一篇关于栈和队列操作实训心得的指南性文章吧。

嘿,朋友们!咱来说说栈和队列的操作实训,这可真是一次有趣又充满挑战的经历呢!你想想看,栈就像是一个特别有原则的小家伙,它呀,遵循着后进先出的规则。

这就好比你把一堆东西往箱子里放,最后放进去的得最先拿出来。

在实训的时候,我就感觉自己像是在和这个有点“倔强”的栈打交道,每一步操作都得小心翼翼,不然就可能弄错顺序啦!队列呢,则是个非常守规矩的好孩子,先进先出,多公平呀!就像排队买东西,先来的先得到服务。

操作队列的时候,就好像在指挥一场有序的行动,要确保每个元素都能按照正确的顺序前进。

在实训过程中,我发现对栈和队列的理解真不能只停留在理论上。

比如说,在实际编程中,怎么合理地利用栈来实现一些功能,这可不是看看书就能明白的呀!得自己动手去试试,去犯错,然后才能真正掌握。

就好像学骑自行车,不摔几跤怎么能骑得稳呢?还有啊,在处理一些复杂问题的时候,栈和队列简直就是大救星!它们能帮我们把问题分解得更加清晰,让我们找到解决问题的思路。

这就像是在一团乱麻中找到了线头,只要顺着拉,就能把整个乱麻解开。

我记得有一次,我在写一个程序,怎么都觉得逻辑混乱。

后来我试着用栈来管理一些数据,哇塞,一下子就豁然开朗了!那感觉,就像是在黑暗中突然看到了亮光,别提多兴奋了。

咱们学习栈和队列的操作,可不能只是为了应付考试或者完成任务,而是要真正理解它们的用处和魅力呀!它们就像是我们编程世界里的两个好帮手,能帮我们解决很多难题呢!大家想想,要是没有栈和队列,我们的程序会变得多么混乱呀!就好像没有了交通规则的马路,那还不得乱套了?所以呀,我们要好好对待它们,和它们成为好朋友。

总之呢,栈和队列的操作实训让我收获满满。

我学会了如何更巧妙地运用它们,也明白了理论和实践结合的重要性。

这可不是随便说说就能懂的,得自己去体验,去感受!大家也赶紧去试试吧,相信你们也会有不一样的收获和感悟!别再犹豫啦,赶紧行动起来吧!。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《数据结构》课程实验实验报告三第三章栈和队列的操作实验题目:实验三栈和队列的操作学号:11416106 班级:计算机111 姓名:张婷指导教师:游静实验完成时间:2013.4.22实验成绩:实验三栈和队列的操作一、实验学时 2学时二、背景知识1.栈:(1).入栈和进栈操作只能从栈顶一端进行;(2).LIFO(后进先出);(3).栈的两种存储定义:顺序栈和链式栈。

2.队列:(1).入队操作从队尾进行,出队操作从对头进行;(2).FIFO(先进先出);(3).队列的两种存储定义:顺序队和链队。

三、目的要求1.掌握栈的顺序表示和实现。

Typedef struct{SelemType *base;SelemType *base;Int stacksize;}sqstack;2.掌握队列的链式表示和实现以及顺序表示和实现。

链队列:Typedef struct Qnode{QelemType data;struct Qnode *next;} Qnode,*Queueptr;Typedef struct{Queueptr front;Queueptr rear;}linkQueue;顺序队列:#define MAXQSIZE 100Typedef struct{Qelemtype *base;int front;int rear;}sqQueue;四、实验内容1.顺序栈和循环队列的创建、入栈(队)、出栈(队)等基本操作。

2.数制转换问题【问题描述】十进制数N和其它d进制数的转换是计算机实现计算的基本问题。

试编制一段程序满足下列要求:对于输入的任意一个非负十进制整数,打印输出与其等值的八进制数。

【基本要求】首先初始化一个顺序栈,通过入栈出栈操作辅助完成数制的转换操作。

五、程序实例:顺序队列的入队和出队操作。

【问题描述】使有数组创建队列。

程序使有选项运行队列的操作,如:输入1表示元素入队,输入2表示元素出队,输入3表示结束程序运行,并且将队列剩余元素输出。

【基本要求】首先使有数组创建队列,然后编写入队函数和出队函数,最后编写主函数。

【测试数据】如:输入队列的元素是:[2][3][4][5][6]取出队列的元素是:[2]剩余队列的元素是:[3][4][5][6]【实现提示】#define MAXQUEUE 10 /* 队列的最大容量 */int queue[MAXQUEUE]; /* 队列的数组定义 */int front = -1; /* 队头 */int rear = -1; /* 队尾 *//*―――――――――――入队―――――――――――*/int enqueue(int value){if ( rear >= MAXQUEUE ) /* 检查队列是否全满 */return -1; /* 无法存入 */rear++; /* 队尾指针前移 */queue[rear] = value; /* 存入队列 */}/*―――――――――――出队―――――――――――*/int dequeue(){if ( front == rear ) /* 检查队列是否为空 */return -1; /* 无法取出 */front++; /* 队头指针前移 */return queue[front]; /* 队列取出 */}六、实验结果1、第一题顺序栈实现#include<stdio.h>#define ElementType char#define maxsize 40typedef struct{ElementType data[maxsize];int top;} SqStackTp;int InitStack(SqStackTp *sq){sq->top=0;return(1);}int Push(SqStackTp *sq,DataType x) {if(sq->top== maxsize-1){printf("栈满"); return(0);}else{sq->top++;sq->data[sq->top]=x;return(1);}}int Pop(SqStackTp *sq,DataType *x){ if (sq->top==0){printf("下溢"); return(0);}else {*x=sq->data[sq->top];sq->top--;return(1);}}int EmptyStack(SqStackTp *sq){if (sq->top==0) return(1);else return(0);}/*主函数*/void main(){SqStackTp sq;ElementType ch;InitStack(&sq);for (ch='A';ch<='A'+12;ch++){Push(&sq,ch);printf("%c",ch);}printf("\n");while(!EmptyStack(&sq)){Pop(&sq,&ch);printf("%c",ch);}printf("\n");队列的实现#include<iostream>#include<stdlib.h>#define MAX 5 /* 队列的最大容量 *//*―――――――――――队列定义―――――――――――*/Struct queue{int *base;int front;int rear;};Typedef struct queue Queue;/*―――――――――――建队―――――――――――*/queue* initqueue(Queue *q){q->base-new int [MAX];if(!Q->base){cout<<”建队失败,内存申请不成功”<<endl;return NULL;}q->front=q->rear=0;return q;}/*―――――――――――入队―――――――――――*/int enqueue(Queue *q,int value){q->base[q->rear]=value;if((q->rear+1)%MAX==q->front){cout<<”队已满”;return -1;}q->rear=(q->rear+1)%MAX;return value;}/*―――――――――――出队―――――――――――*/int dequeue(Queue *q){if ( q->front ==q-> rear ) { /* 检查队列是否为空 */ cout<<”队已空”<<endl;return -1;} /* 无法取出 */int x;x=q->base[(q->front)%=MAX];q->front++; /* 队头指针前移 */return x; /* 队列取出 */}/*―――――――――――出队―――――――――――*/int printqueue(Queue *q){if(q->front==q->rear){cout<<”队中已无元素”<<endl;return -1;}cout<<”队中元素依次为:”;while(q->front!=q->rear)cout<<”[”<<dequeue(q)<<”]”;cout<<endl;}/*―――――――――――主程序―――――――――――*/int main(){queue *q;q=new Queue;initqueue(q);cout<<”please input five elements into queue”<<endl;int x=0;int m;int i;cin>>i;while(1){switch(i){case 1:m=dequeue(q,x+1); <<m<<endl;if(m!=-1)x++;break;case 2: <<dequeue(q)<<endl;break;case 3:printqueue(q);exit(0);default:cout<<”请重新输入”<<endl;}cin>>i;}return 0;}2、第二题进制转换#include<iostream>#include<malloc.h>#include<stdlib.h>#define STACK_INIT_SIZE 20#define STACKINCREMENT 10#define ERROR 0#define OK 1#define OVERFLOW -2typedef int SElemtype;typedef struct{SElemtype *base;SElemtype *top;int Stacksize;}ZGstack;int InitStack(ZGstack &L){L.base=(SElemtype *)malloc(STACK_INIT_SIZE * sizeof(SElemtype));if(!L.base) return ERROR;L.top=L.base;L.Stacksize=STACK_INIT_SIZE;return OK;}PushStack(ZGstack &L,SElemtype e){if(L.top-L.base==L.Stacksize)L.base=(SElemtype*)realloc(L.base,(L.Stacksize+STACKINCREMENT)*sizeof(SElemtype );if(!L.base) exit(OVERFLOW);L.top=L.base+L.Stacksize;L.Stacksize+=STACKINCREMENT;}*L.top++=e; return OK;}int PopStack(ZGstack &L,SElemtype &e){if(L.top==L.base) return ERROR;e=*--L.top; //首先使s.top向下移动一位,然后把s.top指向的值赋给e return OK;}int StackEmpty(ZGstack L){if(L.top==L.base) return 1;else return 0;}void main(){ZGstack S;SElemtype e;int m;cout<<"请输入一个十进制数"<<endl; cin>>m;InitStack(S);while(m!=0){e=m%8;PushStack(S,e);m=m/8;}while(!StackEmpty(S)) {PopStack(S,e);cout<<e; }cout<<endl;}栈的实现结果截图队列实现结果截图进制转换结果截图。

相关文档
最新文档