数据结构实验六 堆栈实验

合集下载

实验报告堆栈操作

实验报告堆栈操作

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

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

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

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

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

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

2. 入栈操作:(1)检查堆栈是否已满,如果已满,则无法入栈;(2)将元素添加到堆栈的顶部。

3. 出栈操作:(1)检查堆栈是否为空,如果为空,则无法出栈;(2)从堆栈中移除顶部元素。

4. 取栈顶元素操作:(1)检查堆栈是否为空,如果为空,则无法取栈顶元素;(2)获取堆栈顶部的元素。

5. 判断堆栈是否为空操作:(1)检查堆栈中的元素个数,如果为0,则堆栈为空。

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

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

2. 入栈操作:(1)入栈元素1,堆栈状态:[1];(2)入栈元素2,堆栈状态:[1, 2];(3)入栈元素3,堆栈状态:[1, 2, 3]。

3. 出栈操作:(1)出栈元素3,堆栈状态:[1, 2];(2)出栈元素2,堆栈状态:[1]。

4. 取栈顶元素操作:(1)取栈顶元素1,栈顶元素为1。

5. 判断堆栈是否为空操作:(1)判断堆栈是否为空,结果为“否”。

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

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

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

数据结构栈和队列实验报告实验报告:数据结构栈和队列一、实验目的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),操作效率很高。

堆栈实验报告

堆栈实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

栈的操作(实验报告)

栈的操作(实验报告)

引言:栈是一种常见的数据结构,它具有特殊的操作规则,即先进后出(LIFO)。

本文将介绍栈的操作,并结合实验报告的方式详细阐述栈的概念、基本操作以及应用场景。

概述:栈是一种线性数据结构,由相同类型的元素按照特定顺序排列而成。

在栈中,只能在栈顶进行插入和删除操作,其他位置的元素无法直接访问。

栈具有两个基本操作:压栈(push)和弹栈(pop)。

其中,压栈将一个元素添加到栈顶,弹栈则是删除栈顶的元素。

除了基本操作外,栈还具有其他常见的操作,如获取栈顶元素(top)、判断栈是否为空(empty)等。

正文内容:一、栈的基本操作1.压栈(push)push操作的实现原理和步骤在实际应用中的使用场景和例子2.弹栈(pop)pop操作的实现原理和步骤在实际应用中的使用场景和例子3.获取栈顶元素(top)top操作的实现原理和步骤在实际应用中的使用场景和例子4.判断栈是否为空(empty)empty操作的实现原理和步骤在实际应用中的使用场景和例子5.栈的大小(size)size操作的实现原理和步骤在实际应用中的使用场景和例子二、栈的应用场景1.括号匹配使用栈实现括号匹配的原理和过程在编译器、计算表达式等领域中的应用2.浏览器的后退和前进功能使用栈来记录浏览器访问历史的原理和过程实现浏览器的后退和前进功能3.函数调用和递归使用栈来实现函数调用和递归的原理和过程在程序执行过程中的应用和注意事项4.实现浏览器缓存使用栈来实现浏览器缓存的原理和过程提高用户浏览速度的实际应用案例5.撤销操作使用栈来实现撤销操作的原理和过程在编辑器、图形处理软件等领域的实际应用总结:本文详细介绍了栈的操作,包括基本操作(压栈、弹栈、获取栈顶元素、判断栈是否为空、栈的大小)和应用场景(括号匹配、浏览器的后退和前进功能、函数调用和递归、实现浏览器缓存、撤销操作)。

通过了解栈的操作和应用,我们可以更好地理解数据结构中的栈,并能够在实际问题中灵活运用栈的特性。

栈实验报告实验结论

栈实验报告实验结论

实验目的:1. 理解栈的基本概念和原理;2. 掌握栈的基本操作,如入栈、出栈、判空等;3. 通过实验加深对栈在实际问题中的应用理解。

实验环境:1. 操作系统:Windows 10;2. 编程语言:C++;3. 开发工具:Visual Studio 2019。

实验内容:1. 定义栈的数据结构;2. 实现栈的基本操作;3. 编写实验程序,测试栈的功能。

实验步骤:1. 定义栈的数据结构:使用数组来实现栈,定义栈的最大容量、栈顶指针和栈底指针。

2. 实现栈的基本操作:a. 初始化栈:将栈顶指针和栈底指针都指向栈的底部;b. 判断栈是否为空:如果栈顶指针等于栈底指针,则栈为空;c. 判断栈是否已满:如果栈顶指针等于栈的最大容量减1,则栈已满;d. 入栈:将元素添加到栈顶,如果栈未满,则栈顶指针加1;e. 出栈:从栈顶取出元素,如果栈不为空,则栈顶指针减1;f. 获取栈顶元素:如果栈不为空,则返回栈顶元素。

3. 编写实验程序,测试栈的功能。

实验结果:1. 初始化栈:创建一个最大容量为10的栈,栈顶指针和栈底指针都指向栈的底部。

2. 判断栈是否为空:当栈为空时,判断结果为真;当栈不为空时,判断结果为假。

3. 判断栈是否已满:当栈已满时,判断结果为真;当栈未满时,判断结果为假。

4. 入栈操作:成功将元素添加到栈顶,栈顶指针加1。

5. 出栈操作:成功从栈顶取出元素,栈顶指针减1。

6. 获取栈顶元素:成功获取栈顶元素。

实验结论:1. 通过本次实验,我们深入理解了栈的基本概念和原理,掌握了栈的基本操作,如入栈、出栈、判空等。

2. 实验结果表明,我们成功实现了栈的数据结构,并实现了栈的基本操作。

3. 在实际应用中,栈是一种常用的数据结构,可以用于解决许多问题,如括号匹配、表达式求值、函数调用等。

通过本次实验,我们对栈在实际问题中的应用有了更深入的理解。

4. 实验过程中,我们遇到了一些问题,如栈的初始化、栈的判空、栈的判满等。

数据结构堆栈实验报告

数据结构堆栈实验报告

数据结构堆栈实验报告篇一:数据结构-堆栈和队列实验报告实验报告实验二堆栈和队列实验目的: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)的操作。

实验周堆栈实验报告

实验周堆栈实验报告

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

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

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

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

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

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

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

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

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

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

数据结构栈的实验报告

数据结构栈的实验报告

数据结构栈的实验报告篇一:数据结构栈和队列实验报告一、实验目的和要求(1)理解栈和队列的特征以及它们之间的差异,知道在何时使用那种数据结构。

(2)重点掌握在顺序栈上和链栈上实现栈的基本运算算法,注意栈满和栈空的条件。

(3)重点掌握在顺序队上和链队上实现队列的基本运算算法,注意循环队队列满和队空的条件。

(4)灵活运用栈和队列这两种数据结构解决一些综合应用问题。

二、实验环境和方法实验方法:(一)综合运用课本所学的知识,用不同的算法实现在不同的程序功能。

(二)结合指导老师的指导,解决程序中的问题,正确解决实际中存在的异常情况,逐步改善功能。

(三)根据实验内容,编译程序。

实验环境:Windows xpVisual C++6.0三、实验内容及过程描述实验步骤:①进入Visual C++ 6.0集成环境。

②输入自己编好的程序。

③检查一遍已输入的程序是否有错(包括输入时输错的和编程中的错误),如发现有错,及时改正。

④进行编译和连接。

如果在编译和连接过程中发现错误,频幕上会出现“报错信息”,根据提示找到出错位置和原因,加以改正。

再进行编译,如此反复直到不出错为止。

⑤运行程序并分析运行结果是否合理。

在运行是要注意当输入不同的数据时所得结果是否正确,应运行多次,分别检查在不同情况下结果是否正确。

实验内容:编译以下题目的程序并调试运行。

1)、编写一个程序algo3-1.cpp,实现顺的各种基本运算,并在此基础上设计一程序并完成如下功能:(1)初始化栈s;(2)判断栈s是否非空;序栈个主(3)依次进栈元素a,b,c,d,e;(4)判断栈s是否非空;(5)输出出栈序列;(6)判断栈s是否非空;(7)释放栈。

图3.1 Proj3_1 工程组成本工程Proj3_1的组成结构如图3.1所示。

本工程的模块结构如图3.2所示。

图中方框表示函数,方框中指出函数名,箭头方向表示函数间的调用关系。

图3.2 Proj3_1工程的程序结构图其中包含如下函数:InitStack(SqStack * s) //初始化栈SDestroyStack(SqStack * s) //销毁栈sStackEmpty(SqStack *s) //判断栈空Push(SqStack * s,ElemType e) //进栈Pop(SqStack * s,ElemType e) //出栈GetTop(SqStack *s,ElemType e) //取栈顶元素对应的程序如下://文件名:algo3-1.cpp#include stdio.h#include malloc.h#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;void InitStack(SqStack * s) //初始化栈S { s=(SqStack *)malloc(sizeof(SqStack));s- top=-1; //栈顶指针置为-1}void DestroyStack(SqStack * s) //销毁栈s{free(s);}bool StackEmpty(SqStack *s) //判断栈空{return(s- top==-1);}bool Push(SqStack * s,ElemType e) //进栈{ if (s- top==MaxSize-1) //栈满的情况,即栈上溢出 return false;s- top++; //栈顶指针增1s- data[s- top]=e; //元素e放在栈顶指针处return true;}bool Pop(SqStack * s,ElemType e) //出栈{ if (s- top==-1) //栈为空的情况,即栈下溢出return false;e=s- data[s- top]; //取栈顶指针元素的元素s- top--;//栈顶指针减1return true;}bool GetTop(SqStack *s,ElemType e) //取栈顶元素 { if (s- top==-1) //栈为空的情况,即栈下溢出return false;e=s- data[s- top]; //取栈顶指针元素的元素return true;}设计exp3-1.cpp程序如下 //文件名:exp3-1.cpp#include stdio.h#include malloc.h#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;extern void InitStack(SqStack *extern void DestroyStack(SqStack *extern bool StackEmpty(SqStack *s);extern bool Push(SqStack * s,ElemType e);extern bool Pop(SqStack * s,ElemTypeextern bool GetTop(SqStack *s,ElemTypevoid main(){ElemType e;SqStack *s;printf( 栈s的基本运算如下:\nprintf( (1)初始化栈s\nInitStack(s);printf( (2)栈为%s\n ,(StackEmpty(s)? 空 : 非空 )); printf( (3)依次进栈元素a,b,c,d,e\nPush(s, aPush(s, bPush(s, cPush(s, dPush(s, eprintf( (4)栈为%s\n ,(StackEmpty(s)? 空 : 非空 )); printf( (5)出栈序列:while (!StackEmpty(s)){Pop(s,e);printf( %c ,e);}printf( \nprintf( (6)栈为%s\n ,(StackEmpty(s)? 空 : 非空 ));printf( (7)释放栈\nDestroyStack(s);}运行结果如下:2)、编写一个程序algo3-2.cpp,实现链栈的各种基本运算,并在此基础上设计一个主程序并完成如下功能:(1)初始化链栈s;(2)判断链栈s是否非空;(3)依次进栈a,b,c,d,e;(4)判断链栈s是否非空;(5)输出链栈长度;(6)输出从栈底到栈顶元素;(7)输出出队序列;(8)判断链栈s是否非空;图3.3 Proj3_2工程组成(9)释放队列。

数据结构与算法实验报告C++版资料

数据结构与算法实验报告C++版资料

算法与数据结构实验报告实验一:栈与队列一、实验目的1、掌握栈和队列特点、逻辑结构和存储结构2、熟悉对栈和队列的一些基本操作和具体的函数定义。

3、利用栈和队列的基本操作完成一定功能的程序。

二、实验任务1.出顺序栈的类定义和函数实现,利用栈的基本操作完成十进制数N与其它d进制数的转换。

(如N=1357,d=8)2.给出顺序队列的类定义和函数实现,并利用队列计算并打印杨辉三角的前n行的内容。

(n=8)3.给出链栈的类定义和函数实现,并设计程序完成如下功能:读入一个有限大小的整数n,并读入n个数,然后按照与输入次序相反的次序输出各元素的值。

三、实验原理1、将十进制数N转化为d进制时,用除去余数法,用d除N所得余数作为d进制当前个位,将相除所得的商的整数部分作为新的N值重复上述计算,直到N为0为止。

将前所得到的各余数反过来连接便得到最终结果。

将每次求出的余数入栈,求解结束后,再依次出栈。

2、在杨辉三角中可用上一行的数来求出对应位置的下一行的内容。

用队列保存上行内容,每当由上行的两个数求出下行的一个数时,其中的前一个便需要删除,而求出的数就入队。

为便于求解,在每行的第一个位置添加一个0作为辅助。

3、输出操作应在读入所有输入的整数后才能进行,用栈来存储这些数据,调用入栈出栈函数实现相关功能。

四、程序清单第一题#include <iostream.h>#ifndef STACK_H#define STACK_Hconst int maxlen=256;typedef int elementtype;enum error_code{success, underflow, overflow};class stack{public:stack();bool empty() const;bool full() const;error_code get_top(elementtype &x) const;error_code push(const elementtype x);error_code pop();private:int count;elementtype data[maxlen];};stack::stack(){count=0;} bool stack::empty() const{if(count==0) return true;return false;}error_code stack::get_top(elementtype &x) const{if(empty()) return underflow;else{x=data[count-1];return success;}}error_code stack::push(const elementtype x) {if(full()) return overflow;data[count]=x;count++;return success;}error_code stack::pop(){if(empty()) return underflow;count--;return success;}bool stack::full() const{if(count==maxlen) return true;return false;}#endifvoid Dec_to_Ocx(int N, int d){ stack S;int Mod,x;while(N!=0){ Mod=N%d;S.push(Mod);N=N/d;}while(!S.empty()){ S.get_top(x);S.pop();cout<<x;}}void main(){ int N;int d;cin>>N;cin>>d;Dec_to_Ocx(N,d);}第二题#include <iostream.h>const int maxlen=256;typedef int elementtype;enum error_code{success, underflow, overflow};class queue{public:queue();bool empty()const;bool full()const;error_code get_front(elementtype &x) const;error_code append(const elementtype x);error_code serve();private:int count;int front,rear;elementtype data[maxlen];};queue::queue(){count=0; front=rear=0;}bool queue::empty()const{if(count==0) return true;return false;}bool queue::full()const{if(count==maxlen-1) return true;return false; }error_code queue::get_front(elementtype &x)const{if(empty()) return underflow;x=data[(front+1)%maxlen];return success;}error_code queue::append(const elementtype x){if(full()) return overflow;rear=(rear+1)%maxlen;data[rear]=x;count ++;return success;}error_code queue::serve(){if(empty()) return underflow;front=(front+1)%maxlen;count--;return success;}void Out_Number(int n){ int s1,s2; queue Q;int i,j;error_code Ec;cout<<1<<endl;Ec=Q.append(1);for(i=2; i<=n; i++){ s1=0;for(j=1; j<=i-1; j++){ Ec= Q.get_front(s2); Ec=Q.serve( );cout<<s1+s2;Ec=Q.append(s1+s2);s1=s2;}cout<<1<<endl;Ec=Q.append(1);}}void main(){ int n;cin>>n;Out_Number(n);}第三题#include <iostream.h>#ifndef STACK_H#define STACK_Hconst int maxlen=256;typedef struct linklist{ int data;struct linklist *next;}node;typedef int elementtype;enum error_code{success, underflow, overflow};class stack{public:stack();~stack();bool empty() const;bool full() const;error_codeget_top(elementtype &x)const;error_code push(const elementtype x);error_code pop();private:int count;node*top;};stack::stack(){ count = 0; top = NULL; }bool stack::empty( )const{ return count == 0; }bool stack::full( )const{ return false; }error_code stack::get_top(elementtype &x)const{if ( empty() ) return underflow;x = top -> data;return success;}stack::~stack( ){while ( !empty() ) pop( );}error_code stack::push(const elementtype x ){node* s;s = new node; s -> data = x;s->next=top; top = s;count ++;return success;}error_code stack::pop( ){if ( empty() ) return underflow;node* u;u = top; top=top->next;delete u;count --;return success;}#endifvoid read_write(){stack S;int x,n,i;cout<<"please put intp int number n";cin>>n;for(i=1;i<=n;i++){ cin>>x;S.push(x);}while(S.empty()!=true){S.get_top(x);S.pop();cout<<x;}}void main(){ read_write();}五、运行结果1、2、3、实验二:单链表一、实验目的:1、理解线性表的链式存储结构。

《数据结构》课程实验实训报告--堆栈和队列的基本操作。

《数据结构》课程实验实训报告--堆栈和队列的基本操作。
}
if(StackTop(myStack,&x)==0)
{
printf("error!\n");
return;
}
else
printf("The element of local top is :%d\n",x);
printf("The sequence of outing elements is:\n");
(*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; } /*出栈操作:*/
依次把5个元素入栈然后出栈并在屏幕上显示出栈的数据元对顺序循环队列常规的方法是使用队尾指针和队头指针队尾指针用于指示当前的队尾位置下标队头指针用于指示当前的队头位置下标
《数据结构》课程实验实训报告

堆栈实验报告

堆栈实验报告

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

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

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

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

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

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

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

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

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

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

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

《数据结构》实验书

《数据结构》实验书

目录实验一线性表基本操作的编程实现 (201)实验二堆栈或队列基本操作的编程实现 (49)实验四二维数组基本操作的编程实现 (18)实验五二叉树基操作的编程实现 (20)实验六图基本操作的编程实现 (45)(特别提示:程序设计包含两个方面的错误。

其一是错误,其二是能错误。

为了提高学生的编程和能力,本指导书给出的程序代码并的两种错误。

并且也不保证程序的完整性,有一些语句已经故意删除,就是要求学生自己编制完成,这样才能达到我们的要求。

希望大家以自己所学高级语言的基本功和点为基础,不要过于依赖给出的参考代码,这样才能有所进步。

如果学生能够根据要求完全自己编制,那就不好了。

)实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求:线性表基本操作的编程实现(2学时,验证型),掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构可以在顺序结构或链表结分主要功能,也可以用菜单进行管理完成大部分功能。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。

建议实现键盘输入数据以实现程序的通据的函数。

【注意事项】【思考问题】1.线性表的顺序存储和链表存储的差异?优缺点分析?2.那些操作引发了数据的移动?3.算法的时间效率是如何体现的?4.链表的指针是如何后移的?如何加强程序的健壮性?【参考代码】(一)利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1)#define ListSize //根据需要自己设定一个班级能够容纳的最大学生数(2)typedef struct Stu{int num; //学生的学号char name[10]; //学生的姓名float wuli; //物理成绩float shuxue; //数学成绩float yingyu; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{stu[ListSize]; //存放学生的数组定义,静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=0;i<m;i++) //输入m个学生的所有信息{printf("please input the %dth student's information:\n",i+1);printf("num=");scanf("%d", ); //输入第i个学生的学号printf("name=");scanf("%s", ); //输入第i个学生的姓名printf("wuli=");scanf("%f", ); //输入第i个学生的物理成绩printf("shuxue=");scanf("%f", ); //输入第i个学生的数学成绩printf("yingyu=");scanf("%f", ); //输入第i个学生的英语成绩Li->length++; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。

堆栈应用实验报告

堆栈应用实验报告

堆栈应用实验报告一、实验目的本实验主要是通过堆栈的实际应用来进一步深入了解堆栈的概念、原理和使用方法,并学会基于堆栈的算法设计和编程。

二、实验器材1.计算机本身及编程环境。

2.编程软件:Visual Studio 2010(或以上版本)。

三、实验内容及要求1.堆栈的定义与基本操作。

2.堆栈的应用。

(1)逆波兰表达式求值。

(2)括号匹配。

四、实验原理堆栈是一种先进后出的数据结构,常见的基本操作包括以下几个:入栈(Push),将元素添加到堆栈的上方。

出栈(Pop),弹出并返回堆栈的顶部元素。

判空(Empty),判断堆栈是否为空。

堆栈的数据结构通常有两种实现方法:数组实现链表实现逆波兰表达式(Reverse Polish Notation)是一种后缀表达式,其中操作符写在操作数的后面,例如,“1 2 +”等价于中缀表达式“1 + 2”。

使用堆栈可以方便的求解逆波兰表达式,步骤如下:遍历逆波兰表达式,遇到操作数则入栈。

遇到操作符时,弹出栈顶两个元素,进行运算,并将结果入栈。

将最终结果从栈中弹出。

括号匹配问题是指给定一个字符串,判断其中的括号是否成对出现,且出现顺序正确,例如“()”,“(())”等都属于匹配的情况,但“([)]”不匹配。

遍历字符串,遇到左括号则入栈。

遇到右括号时,弹出栈顶元素进行匹配,如果匹配成功则继续遍历,否则直接返回不匹配。

遍历完成后,若堆栈为空,则返回匹配,否则返回不匹配。

五、实验过程```c++#include<iostream>using namespace std;const int MAXN = 10001;int stk[MAXN], top;struct node {char data;node* next;};node* stk;void pop() {if (empty()) return;node* p = stk;stk = stk->next;delete p;}bool empty() {return top == 0;}bool match(char a, char b) {if (a == '(' && b == ')') return true;if (a == '[' && b == ']') return true;if (a == '{' && b == '}') return true;return false;}六、实验结果输入:"5 1 2 + 4 * + 3 -"输出:"14"七、实验心得对于入门学习堆栈的同学来说,可以先尝试使用基本数据结构(数组或链表)实现堆栈,并完成一些简单的堆栈操作。

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

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

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

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

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

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

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

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

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

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

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

2. 队列的实现:队列是一种先进先出(FIFO)的数据结构,类似于我们日常生活中的排队。

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

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

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

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

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

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

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

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

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

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

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

数据结构实验报告-栈和队列(迷宫图最短路径)

数据结构实验报告-栈和队列(迷宫图最短路径)

目录一、实验要求(需求分析) (1)a. 实验目的 (1)b. 实验内容 (2)c.程序功能 (2)二、程序分析 (2)2.1 存储结构 (2)2.2 关键算法分析 (3)三、程序运行分析 (7)1.程序运行流程图: (7)2.程序运行结果截图: (8)四.总结 (10)五、附录 (11)一、实验要求(需求分析)a. 实验目的通过实验,掌握如下内容:➢进一步掌握指针、模板类、异常处理的使用➢掌握队列的操作的实现方法➢学习使用队列解决实际问题的能力➢学习使用图的广度优先搜索解决实际问题的能力b. 实验内容利用队的结构实现迷宫求解问题。

迷宫求解问题如下:心理学家把一只老鼠从一个无顶盖的大盒子的入口赶进迷宫,迷宫中设置很多隔壁,对前进方向形成了多处障碍,心理学家在迷宫的唯一出口放置了一块奶酪,吸引老鼠在迷宫中寻找通路以到达出口,测试算法的迷宫如下图所示。

c.程序功能输入起始点的坐标,输出走出迷宫最短路径的长度。

二、程序分析2.1 存储结构存储结构: 队列顺序存储结构示意图如下:2.2 关键算法分析核心算法思想:1.如果采用直接递归的方式,用栈很容易实现路径的输出,但是这条路径不一定是最短路径。

为了改进算法,达到输出最短路径的目标,采用队列的实现方式。

2.为查找最短路径,使用了“图”中的算法:广度优先搜索。

关键算法思想描述和实现:关键算法1:为寻求最短路径,采用广度优先搜索算法,使用队列实现路径存储,队列中每个元素用结构体存储系,包含迷宫坐标、队列中的序号、父节点的序号,实现了对路径的记录。

C++实现:struct Node{int parent_id; //保存父节点的位置int node_id; //当前节点的序号,以便传递给孩子节点int x,y; //当前结点对应的坐标}Q[10*10]; //每个节点包含迷宫坐标、队列中的序号、父节点的序号,多个节点形成队列关键算法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`,表示括号匹配错误。

C语言数据结构中栈操作实验

C语言数据结构中栈操作实验

C语言数据结构中栈操作实验C语言数据结构中栈操作实验c语言中栈是一种数据结构,后进先出,即最后进入栈的数据最先弹出。

以下是店铺搜索整理的关于C语言数据结构中栈操作实验,需要的朋友可以参考一下!想了解更多相关信息请持续关注我们店铺!实验:编写一个程序实现顺序栈的各种基本运算,并在此基础上设计一个主程序,完成如下功能:(1)初始化顺序栈(2)插入元素(3)删除栈顶元素(4)取栈顶元素(5)遍历顺序栈(6)置空顺序栈分析:栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。

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

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

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

注意:(1)顺序栈中元素用向量存放(2)栈底位置是固定不变的,可设置在向量两端的任意一个端点(3)栈顶位置是随着进栈和退栈操作而变化的,用一个整型量top(通常称top为栈顶指针)来指示当前栈顶位置顺序栈的实现:#include <stdio.h>#include <malloc.h>typedef int SElemType;typedef int Status;#define INIT_SIZE 100#define STACKINCREMENT 10#define Ok 1#define Error 0#define True 1#define False 0typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;//初始化栈Status InitStack(SqStack *s){s->base = (SElemType *)malloc(INIT_SIZE * sizeof(SElemType));if(!s->base){puts("存储空间分配失败!");return Error;}s->top = s->base;s->stacksize = INIT_SIZE;return Ok;}//清空栈Status ClearStack(SqStack *s)s->top = s->base;return Ok;}//栈是否为空Status StackEmpty(SqStack *s){if(s->top == s->base)return True;elsereturn False;}//销毁栈Status Destroy(SqStack *s){free(s->base);s->base = NULL;s->top = NULL;s->stacksize=0;return Ok;}//获得栈顶元素Status GetTop(SqStack *s, SElemType &e) {if(s->top == s->base) return Error;e = *(s->top - 1);return Ok;}//压栈Status 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){puts("存储空间分配失败!");return Error;}s->top = s->base + s->stacksize;//修改栈顶位置s->stacksize += STACKINCREMENT;//修改栈长度}*s->top++ = e;return Ok;}//弹栈Status Pop(SqStack *s, SElemType *e){if(s->top == s->base) return Error;--s->top;*e = *(s->top);return Ok;}//遍历栈Status StackTraverse(SqStack *s,Status(*visit)(SElemType)){SElemType *b = s->base;//此处不能直接用base或top移动,即不能改变原栈的结构SElemType *t = s->top;while(t > b)visit(*b++);printf(" ");return Ok;}Status visit(SElemType c) {printf("%d ",c);return Ok;}测试代码:int main(){SqStack a;SqStack *s = &a; SElemType e;InitStack(s);int n;puts("请输入要进栈的个数:"); scanf("%d", &n);while(n--){int m;scanf("%d", &m);Push(s, m);}StackTraverse(s, visit);puts("");puts("8进栈后:");Push(s, 8);StackTraverse(s, visit);puts("");Pop(s, &e);printf("出栈的元素是:%d ", e);printf("元素出栈后事实上并没有清除,依然存在于内存空间,所谓的出栈只是指针移动,出栈的元素是%d ", *s->top);//判断出栈后元素是否还存在于内存中Destroy(s);return 0;}运行结果:。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
setnum(num);
}
六,调试分析
在将十进制数转换为二进制数函数中,调用出栈函数pop时实参弄错,写成pop(s),应为pop(&s),因为定义是:pop(seqstack *s),调用时,不能将seqstack转换成seqstack*。故提示pop(s)出错。
七,使用手册
该程序是把一个十进制整数转化为二进制数输出,操作较简单,根据提示直接输入一个十进制整数,运行后即可输出一个相对应的二进制数。
s->top=-1;
return s;
}
void push(seqstack *s,int x){ //顺序栈入栈算法
if(s->top<=maxlen-1&&s->top>=-1){
s->top++;
s->data[s->top]=x;
}
else printf("error");
}
void pop(seqstack *s){ //顺序栈出栈算法
typedef struct{
int data[maxlen];
int top;
}seqstack;
2,顺序栈入栈函数的伪代码:
void push(seqstack *s,int x){
if(s->top<=maxlen-1&&s->top>=-1){
s->top++;
s->data[s->top]=x;}
while(num){int k=num%2;
push(&s,k);
num=num/2;}
while(!stackempty(&s)){
int x=gettop(&s);
printf("%d",x);
pop(&s);}}
五,源代码
#include "stdio.h"
#define maxlen 100
一,实验题目
实验六堆栈实验
设计算法,把一个十进制整数转化为二进制数输出。
二,问题分析
本程序要求将一个十进制整数转化为二进制数输出。完成此功能所要解决的问题是熟练掌握和运用入栈和出栈操作,实现十进制整数转化为二进制数。
(1)数据的输入形式和输入值得范围:输入的是一个十进制整数,且其为正整数。
(2)结果的输出形式:输出的是一个二进制整数
else printf("error");}
3,顺序栈出栈函数的伪代码:
void pop(seqstack *s){
if(s->top>=0)s->top--;
elseprintf("error");}
4,将十进制数转换为二进制数函数伪代码:
void setnum(int num){
seqstack s;initstack(&s);
if(s->top>=0)
s->top--;
else
printf("error");
}
int gettop(seqstack *s){ //顺序栈取栈顶元素算法
if(s->top<=maxlen-1&&s->tቤተ መጻሕፍቲ ባይዱp>=0)
return(s->data[s->top]);
else
printf("error");
typedef struct{ //定义顺序栈的结构类型
int data[maxlen];
int top;
}seqstack;
int stackempty(seqstack *s){ //顺序栈判栈空算法
if(s->top>=0)
return 0;
else
return 1;
}
seqstack *initstack(seqstack *s){ //顺序栈置空栈算法
4)顺序栈入栈函数push(seqstack *s,int x)
5)顺序栈出栈函数pop(seqstack *s)
6)顺序栈取栈顶元素函数gettop(seqstack *s)
7)将十进制数转换为二进制数函数setnum(int num)
各函数间关系如下:
initstack(&s)
四,详细设计
1,顺序表的结构类型定义:
(3)测试数据:1)9 2)4500
三,概要设计
1.为了实现上述程序功能,需要:
构造一个空的顺序栈s
将十进制整数除以2的余数入栈
将余数按顺序出栈
2.本程序包含7个函数:
1)主函数main();
2)顺序栈判栈空函数stackempty(seqstack *s)
3)顺序栈置空栈函数seqstack *initstack(seqstack *s)
int x=gettop(&s); //取栈顶元素
printf("%d",x); //按序输出栈顶元素
pop(&s); //出栈
}
printf("\n");
}
void main(){
int num;
printf("请输入一个十进制数:");
scanf("%d",&num);
printf("该十进制数转换成的二进制数为:");
}
void setnum(int num){ //将十进制数转换为二进制数函数
seqstack s; //定义一个顺序栈类型变量s
initstack(&s); //置空栈s
while(num){ //进制转化
int k=num%2;
push(&s,k);
num=num/2;
}
while(!stackempty(&s)){ //当栈不为空时
八,测试结果
1,输入的十进制整数为9:
2,输入的十进制整数为4500:
相关文档
最新文档