数据结构实验—栈及其应用

合集下载

栈的实验报告结论(3篇)

栈的实验报告结论(3篇)

第1篇一、实验目的1. 理解栈的基本概念和操作;2. 掌握栈的顺序存储和链式存储实现方法;3. 熟悉栈在程序设计中的应用。

二、实验内容1. 栈的顺序存储结构实现;2. 栈的链式存储结构实现;3. 栈的基本操作(入栈、出栈、判空、求栈顶元素);4. 栈在程序设计中的应用。

三、实验方法1. 采用C语言进行编程实现;2. 对实验内容进行逐步分析,编写相应的函数和程序代码;3. 通过运行程序验证实验结果。

四、实验步骤1. 实现栈的顺序存储结构;(1)定义栈的结构体;(2)编写初始化栈的函数;(3)编写入栈、出栈、判空、求栈顶元素的函数;(4)编写测试程序,验证顺序存储结构的栈操作。

2. 实现栈的链式存储结构;(1)定义栈的节点结构体;(2)编写初始化栈的函数;(3)编写入栈、出栈、判空、求栈顶元素的函数;(4)编写测试程序,验证链式存储结构的栈操作。

3. 栈在程序设计中的应用;(1)实现一个简单的四则运算器,使用栈进行运算符和操作数的存储;(2)实现一个逆序输出字符串的程序,使用栈进行字符的存储和输出;(3)编写测试程序,验证栈在程序设计中的应用。

五、实验结果与分析1. 顺序存储结构的栈操作实验结果:(1)入栈操作:在栈未满的情况下,入栈操作成功,栈顶元素增加;(2)出栈操作:在栈非空的情况下,出栈操作成功,栈顶元素减少;(3)判空操作:栈为空时,判空操作返回真,栈非空时返回假;(4)求栈顶元素操作:在栈非空的情况下,成功获取栈顶元素。

2. 链式存储结构的栈操作实验结果:(1)入栈操作:在栈未满的情况下,入栈操作成功,链表头指针指向新节点;(2)出栈操作:在栈非空的情况下,出栈操作成功,链表头指针指向下一个节点;(3)判空操作:栈为空时,判空操作返回真,栈非空时返回假;(4)求栈顶元素操作:在栈非空的情况下,成功获取栈顶元素。

3. 栈在程序设计中的应用实验结果:(1)四则运算器:成功实现加、减、乘、除运算,并输出结果;(2)逆序输出字符串:成功将字符串逆序输出;(3)测试程序:验证了栈在程序设计中的应用。

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

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

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

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

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

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

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

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

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

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

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

可以使用栈来实现。

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

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

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

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

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

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

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

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

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

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

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

栈及其应用实验报告

栈及其应用实验报告

一、实验目的1. 理解栈的定义、特点、逻辑结构及其在计算机科学中的应用。

2. 掌握顺序栈和链栈的存储结构及基本操作实现。

3. 通过具体应用实例,加深对栈的理解,提高问题分析和解决的能力。

二、实验内容1. 实现顺序栈和链栈的基本操作。

2. 编写一个算法,判断给定的字符序列是否为回文。

3. 编写一个算法,利用栈的基本运算将指定栈中的内容进行逆转。

4. 给定一个整数序列,实现一个求解其中最大值的递归算法。

三、实验步骤1. 实现顺序栈和链栈的基本操作(1)顺序栈的存储结构及操作实现顺序栈使用数组来实现,其基本操作包括:- 初始化栈:使用数组创建一个空栈,并设置栈的最大容量。

- 入栈:将元素插入栈顶,如果栈满,则返回错误。

- 出栈:从栈顶删除元素,如果栈空,则返回错误。

- 获取栈顶元素:返回栈顶元素,但不删除。

- 判断栈空:判断栈是否为空。

(2)链栈的存储结构及操作实现链栈使用链表来实现,其基本操作包括:- 初始化栈:创建一个空链表,作为栈的存储结构。

- 入栈:在链表头部插入元素,如果链表为空,则创建第一个节点。

- 出栈:删除链表头部节点,如果链表为空,则返回错误。

- 获取栈顶元素:返回链表头部节点的数据。

- 判断栈空:判断链表是否为空。

2. 判断字符序列是否为回文编写一个算法,判断给定的字符序列是否为回文。

算法步骤如下:(1)使用顺序栈或链栈存储字符序列。

(2)从字符序列的头部开始,依次将字符入栈。

(3)从字符序列的尾部开始,依次将字符出栈,并与栈顶元素比较。

(4)如果所有字符均与栈顶元素相等,则字符序列为回文。

3. 利用栈的基本运算将指定栈中的内容进行逆转编写一个算法,利用栈的基本运算将指定栈中的内容进行逆转。

算法步骤如下:(1)创建一个空栈,用于存储逆转后的栈内容。

(2)从原栈中依次将元素出栈,并依次入新栈。

(3)将新栈的内容赋值回原栈,实现栈内容的逆转。

4. 求解整数序列中的最大值给定一个整数序列,实现一个求解其中最大值的递归算法。

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

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

数据结构_实验三_栈和队列及其应用(可编辑实验三:栈和队列及其应用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表达式求值:使用栈可以实现对表达式的求值。

数据结构实验-线性表及其实现栈和队列及其应用

数据结构实验-线性表及其实现栈和队列及其应用

数据结构实验报告一实验名称:线性表及其实现栈和队列及其应用1 实验目的及实验要求1.线性表目的要求:(1)熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现,以线性表的各种操作(建立、插入、删除等)的实现为实验重点;(2)通过本次实验帮助学生加深对顺序表、链表的理解,并加以应用;(3)掌握循环链表和双链表的定义和构造方法2.栈和队列目的要求:(1)掌握栈和队列这两种特殊的线性表,熟悉它们的特性,在实际问题背景下灵活运用它们;(2)本实验训练的要点是“栈”的观点及其典型用法;(3)掌握问题求解的状态表示及其递归算法,以及由递归程序到非递归程序的转化方法。

2实验内容及实验步骤(附运行结果截屏)1.线性表实验内容:(1)编程实现线性表两种存储结构(顺序存储、链式存储)中的基本操作的实现(线性表的创建、插入、删除和查找等),并设计一个菜单调用线性表的基本操作。

(2)建立一个按元素递增有序的单链表L,并编写程序实现:a)将x插入其中后仍保持L的有序性;b)将数据值介于min和max之间的结点删除,并保持L的有序性;c)(选做)将单链表L逆置并输出;(3)编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。

注:(1)为必做题,(2)~(3)选做。

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

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

注:(1)~(2)必做,(3)~(5)选做。

实验步骤:先编写线性表和栈和队列的类模板,实现各自的基础结构,之后按照要求编写适当的函数方法(公共接口),最后完成封装。

编写主函数直接调用即可。

核心代码://LinearList.h 顺序表//类的声明1.template<class T>2.class LinearList3.{4.public:5.LinearList(int sz = default_size);6.~LinearList();7.int Length()const; //length of the linear8.int Search(T x)const; //search x in the linear and return its order number9.T GetData(int i)const; //get i th order's data10.bool SetData(int i,T x); //change i th order's data to x11.bool DeleteData(int i);12.bool InsertData(int i,T x);13.void output(bool a,int b,int c); //print the linear14.void ReSize(int new_size);15.16.private:17.T *data;18.int max_size,last_data;19.};//构造函数1.template<class T>2.LinearList<T>::LinearList(int sz)3.{4.if(sz>0)5.{6.max_size = sz;st_data=-1;8.data=new T[max_size];9.if(data == NULL)10.{11.cerr<<"Memory creat error!"<<endl;12.exit(1);13.}14.}15.else16.{17.cerr<<"Size error!"<<endl;18.exit(1);19.}20.}//Qlist.h 链式表//模板类的声明1.template<class T>2.struct LinkNode3.{4.T data;5.LinkNode<T> *link;6.LinkNode(LinkNode<T> *ptr = NULL)7.{8.link = ptr;9.}10.LinkNode(const T item,LinkNode<T> *ptr = NULL)11.{12.data = item;13.link = ptr;14.}15.};16.17.template<class T>18.class Qlist: public LinkNode<T>19.{20.public:21.Qlist();22.Qlist(const T x);23.Qlist(Qlist<T>&L);24.~Qlist();25.void MakeEmpty();26.int Length()const; //length of the linear27.int Search(T x)const; //search x in the linear and return its order number28.LinkNode<T> *Locate(int i);29.T GetData(int i); //get i th order's data30.bool SetData(int i,T x); //change i th order's data to x31.bool DeleteData(int i);32.bool InsertData(int i,T x);33.void output(bool a,int b,int c); //print the linear34.35.protected:36.LinkNode<T> *first;37.};//构造函数1.template<class T>2.Qlist<T>::Qlist(Qlist<T>&L)3.{4.T value;5.LinkNode<T>*src = L.getHead();6.LinkNode<T>*des = first = new LinkNode<T>;7.while(src->link != NULL)8.{9.value = src->link->data;10.des->link = new LinkNode<T>(value);11.des = des->link;12.src = src->link;13.}14.des->link = NULL;15.}截屏:3 实验体会(实验遇到的问题及解决方法)刚开始的时候本想先写线性表的类模板然后分别进行继承写顺序表和链式表甚至是以后的栈和队列。

数据结构实验报告栈

数据结构实验报告栈

数据结构实验报告:栈摘要:本实验报告旨在介绍栈这一重要的数据结构,以及在实际应用中的使用。

栈是一种先进后出(LIFO)的数据结构,在计算机科学中有着广泛的应用。

本报告将详细介绍栈的定义、基本操作以及应用实例,并根据实验结果进行分析和总结。

1. 引言栈是一种基于线性表的数据结构,具有后进先出(LIFO)的特性。

它可以通过两个基本操作来实现:push(入栈)将元素添加到栈顶,pop(出栈)将栈顶元素移除。

栈在计算机科学中被广泛应用,如函数调用、表达式求值、括号匹配等。

2. 栈的实现栈可以通过数组或链表来实现。

数组实现的栈称为顺序栈,链表实现的栈称为链式栈。

无论是哪种实现方式,都需要实现以下基本操作:- push(element): 将元素添加到栈顶。

- pop(): 移除栈顶元素并返回。

- top(): 返回栈顶元素的值。

- isEmpty(): 判断栈是否为空。

- isFull(): 判断栈是否已满(仅顺序栈需要实现)。

3. 栈的应用3.1 函数调用栈在函数调用中起着关键作用。

每当一个函数被调用时,当前函数的局部变量、返回地址等信息都会被压入栈中。

当函数执行完毕时,这些信息会从栈中弹出,继续执行上一级函数。

3.2 表达式求值栈常用于表达式求值,特别是中缀表达式的转换和计算。

通过将中缀表达式转换为后缀表达式,可以方便地进行计算。

栈可以临时存储运算符,并根据运算符的优先级进行弹出和计算。

3.3 括号匹配栈的一个重要应用是括号匹配。

通过遍历字符串,将左括号压入栈中。

每当遇到右括号时,如果栈顶元素是匹配的左括号,则弹出栈顶元素;否则,表示括号不匹配。

4. 实验结果与分析根据我们对栈的实现和应用进行的实验,以下是我们得到的结论:- 通过数组实现的顺序栈在空间上存在一定的限制,可能会出现栈溢出的情况。

- 通过链表实现的链式栈没有空间限制,可以动态地添加和删除元素。

- 栈在函数调用和表达式求值中展现出了高效的性能,并能够简化程序的设计。

栈的运用实验报告

栈的运用实验报告

一、实验目的1. 理解栈的基本概念、特点及逻辑结构;2. 掌握栈的顺序存储和链式存储结构;3. 熟练掌握栈的基本操作,如入栈、出栈、判断栈空等;4. 理解栈在递归算法中的应用;5. 探究栈在实际问题中的应用。

二、实验内容1. 栈的定义与特点2. 栈的顺序存储结构3. 栈的链式存储结构4. 栈的基本操作5. 栈在递归算法中的应用6. 栈在实际问题中的应用三、实验步骤1. 栈的定义与特点(1)栈是一种后进先出(LIFO)的数据结构;(2)栈的元素只能从一端(栈顶)进行插入和删除操作;(3)栈具有两个基本操作:入栈和出栈。

2. 栈的顺序存储结构(1)使用数组来实现栈的顺序存储结构;(2)定义一个数组作为栈的存储空间;(3)定义栈顶指针top,初始值为-1;(4)定义栈的最大容量maxSize。

3. 栈的链式存储结构(1)使用链表来实现栈的链式存储结构;(2)定义一个链表节点,包含数据域和指针域;(3)定义栈顶指针top,初始时指向链表头节点。

4. 栈的基本操作(1)入栈操作:将元素插入到栈顶,栈顶指针向上移动;(2)出栈操作:删除栈顶元素,栈顶指针向下移动;(3)判断栈空:判断栈顶指针是否为-1,是则栈空,否则栈非空。

5. 栈在递归算法中的应用(1)斐波那契数列的递归算法;(2)汉诺塔问题;(3)迷宫问题。

6. 栈在实际问题中的应用(1)括号匹配问题;(2)表达式求值问题;(3)递归函数的调用栈。

四、实验结果与分析1. 栈的定义与特点通过本次实验,我们深入理解了栈的基本概念、特点及逻辑结构,掌握了栈的后进先出特性。

2. 栈的顺序存储结构使用数组实现栈的顺序存储结构,操作简单高效。

在实验过程中,我们实现了栈的基本操作,如入栈、出栈、判断栈空等。

3. 栈的链式存储结构使用链表实现栈的链式存储结构,具有灵活性和扩展性。

在实验过程中,我们实现了栈的基本操作,如入栈、出栈、判断栈空等。

4. 栈的基本操作通过实验,我们熟练掌握了栈的基本操作,如入栈、出栈、判断栈空等,为后续递归算法和实际问题中的应用奠定了基础。

栈的操作(实验报告)

栈的操作(实验报告)

引言:栈是一种常见的数据结构,它具有特殊的操作规则,即先进后出(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.撤销操作使用栈来实现撤销操作的原理和过程在编辑器、图形处理软件等领域的实际应用总结:本文详细介绍了栈的操作,包括基本操作(压栈、弹栈、获取栈顶元素、判断栈是否为空、栈的大小)和应用场景(括号匹配、浏览器的后退和前进功能、函数调用和递归、实现浏览器缓存、撤销操作)。

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

数据结构之栈栈的定义特性和常见应用

数据结构之栈栈的定义特性和常见应用

数据结构之栈栈的定义特性和常见应用栈(Stack)是一种线性数据结构,按照“后进先出”(Last In First Out,LIFO)的原则进行操作。

在栈中,最后插入的元素首先被删除。

栈可以视为容器,它具有两个主要操作:压入(Push)将元素放入栈顶,弹出(Pop)将栈顶元素移出。

本文将介绍栈的定义、特性以及常见应用。

一、栈的定义栈可以使用数组或链表来实现。

使用数组实现的栈称为顺序栈,而使用链表实现的栈则被称为链式栈。

栈的定义包括以下几个重要元素:1. 数据集合:栈内存储的数据元素集合,可以是任意类型的数据。

2. 栈顶指针:指示栈顶元素所在位置的指针,初始时指向空栈。

3. 栈底指针:指示栈底元素所在位置的指针,通常固定不变。

栈的定义可以用如下伪代码表示:```Stack:Data[] elements // 数据集合Integer top // 栈顶指针,初始为空栈```二、栈的特性1. 后进先出(LIFO):栈是按照后进先出的原则进行操作的,最后插入的元素首先被删除。

2. 仅对栈顶操作:栈中只能访问、删除和添加栈顶元素,无法直接访问、删除和添加非栈顶元素,需要先将非栈顶元素出栈。

3. 顺序访问:栈的元素只能按照创建顺序进行访问,无法直接访问栈中间或底部的元素。

4. 有限容量:栈的容量有限,当栈满时无法再插入新的元素,称为栈溢出。

三、栈的常见应用栈广泛应用于计算机科学和软件开发领域,以下是栈常见的应用场景:1. 函数调用:栈用于保存函数的返回地址和局部变量,当函数调用结束时,栈顶指针回退到上一个函数。

2. 括号匹配:使用栈可以轻松解决括号匹配的问题。

通过遍历表达式,将左括号入栈,当遇到右括号时,将栈顶元素出栈并判断是否匹配。

3. 表达式求值:栈可以用来实现中缀表达式转后缀表达式,并且可以通过后缀表达式求解表达式的值。

4. 浏览器前进后退:浏览器的前进和后退功能可以使用两个栈来实现,分别保存浏览历史记录。

数据结构实验报告_栈(3篇)

数据结构实验报告_栈(3篇)

第1篇一、实验目的本次实验旨在通过实际操作,加深对栈这一数据结构的理解,掌握栈的基本操作,包括初始化、入栈、出栈、取栈顶元素、判栈空等。

同时,通过实验练习,提高编程能力和问题解决能力。

二、实验内容1. 栈的定义及特点2. 栈的顺序存储结构3. 栈的链式存储结构4. 栈的基本操作5. 栈的应用实例三、实验过程1. 栈的定义及特点栈是一种后进先出(LIFO)的数据结构,它只允许在一端进行插入和删除操作。

栈的顶元素总是最后被插入的元素,也是最先被删除的元素。

2. 栈的顺序存储结构顺序存储结构是使用数组来实现栈。

定义一个数组作为栈的存储空间,同时定义一个指针top来指示栈顶元素的位置。

3. 栈的链式存储结构链式存储结构是使用链表来实现栈。

定义一个节点结构体,其中包含数据和指向下一个节点的指针。

头节点作为栈顶元素。

4. 栈的基本操作(1)初始化:创建一个空栈,top指针指向栈底。

(2)入栈:将新元素插入到栈顶。

如果栈满,则进行扩容。

(3)出栈:删除栈顶元素,并将其返回。

如果栈空,则返回错误信息。

(4)取栈顶元素:返回栈顶元素的值,但不删除栈顶元素。

(5)判栈空:判断栈是否为空,如果为空,则返回true;否则,返回false。

5. 栈的应用实例(1)括号匹配检验:利用栈判断一个字符串中的括号是否匹配。

(2)算术表达式求值:利用栈实现算术表达式求值,包括四则运算和括号。

四、实验结果与分析1. 初始化栈初始化栈后,栈为空,top指针指向栈底。

2. 入栈操作将元素1、2、3依次入栈,栈的状态如下:```top -> 3 -> 2 -> 1```3. 出栈操作依次出栈元素,栈的状态如下:```top -> 2 -> 1```4. 取栈顶元素取栈顶元素2,栈的状态不变。

5. 判栈空当栈中只有一个元素时,判断栈为空,返回false。

6. 括号匹配检验对于字符串"((()))",括号匹配检验结果为true;对于字符串"(()))",括号匹配检验结果为false。

数据结构实验3 栈的基本操作和应用

数据结构实验3 栈的基本操作和应用

注意事项:在磁盘上创建一个目录,专门用于存储数据结构实验的程序。

因为机房机器有还原卡,请同学们将文件夹建立在最后一个盘中,以学号为文件夹名。

实验三栈的基本操作和应用一、实验目的掌握栈的基本操作:初始化栈、判栈为空、出栈、入栈等运算。

二、实验要求1.认真阅读和掌握本实验的算法。

2.上机将算法实现。

3.将未实现的函数全部实现,并打印出程序的运行结果,结合程序进行分析。

三、实验内容程序1栈的顺序存储表示与实现以及栈的基本操作的算法参考程序如下:#include<iostream.h>#include<stdio.h>#include<malloc.h>#include<conio.h>#define MAXSIZE 100typedef int DataType;struct STACK{DataType data[MAXSIZE];int top;};typedef struct STACK SeqStack;typedef struct STACK *pSeqStack;//函数声明pSeqStack InitStack();void DestroyStack(pSeqStack &S);void ClearStack(pSeqStack &S);int StackEmpty(pSeqStack S);int StackLength(pSeqStack S);int GetTop(pSeqStack S,DataType *e);int Push(pSeqStack *S,DataType e);int Pop(pSeqStack *S,DataType *e);//初始化pSeqStack InitStack()pSeqStack S;S=(pSeqStack)malloc(sizeof(SeqStack));if(S) S->top=-1;return S;}//销毁栈void DestroyStack(pSeqStack &S){if (S)free(S);S=NULL;}//清空栈void ClearStack(pSeqStack &S){S->top=-1;}//判栈空int StackEmpty(pSeqStack S){if (S->top==-1)return 1;elsereturn 0;}//求栈中元素个数int StackLength(pSeqStack S){}//获取栈顶元素值int GetTop(pSeqStack S,DataType *e){}//入栈int Push(pSeqStack &S,DataType e){}//出栈int Pop(pSeqStack *S,DataType *e){}//逆序打印栈中元素void PrintElem(pSeqStack S){int j=S->top ;if(S->top==-1) cout<<"该栈为空栈.";elsewhile(j!=-1){cout<<S->data[j--]<<ends;}cout<<endl;}void main(){DataType e;pSeqStack Sa;cout<<"\n\n-------------------SqStack Demo is running...----------------\n\n"; cout<<"First is Push function.\n";Sa=InitStack();cout<<" 现在栈为空.\n";cout<<"请输入第一个要入栈的元素值:";cin>>e;Push(Sa,e);cout<<"\n 现在栈中有一个元素.\n";PrintElem(Sa);cout<<"请输入第二个要入栈的元素值:";cin>>e;Push(Sa,e);cout<<"\n 现在栈中有两个元素.\n";PrintElem(Sa);int n;cout<<"请输入还要入栈的元素个数:";cin>>n;for(int i=1;i<=n;i++){cout<<"\n请输入第"<<i+2<<"个元素:";cin>>e;Push(Sa,e);}//cout<<"现在栈中元素有:"<<StackLength(Sa)<<"个。

栈队列及其应用实验报告

栈队列及其应用实验报告

一、实验目的1. 理解栈和队列的基本概念、特点及逻辑结构。

2. 掌握栈和队列的存储结构,包括顺序存储结构和链式存储结构。

3. 熟练掌握栈和队列的基本操作,如入栈、出栈、入队、出队等。

4. 分析栈和队列在实际问题中的应用,提高解决实际问题的能力。

二、实验内容1. 栈和队列的定义及特点2. 栈和队列的存储结构3. 栈和队列的基本操作4. 栈和队列的实际应用案例分析三、实验过程1. 栈和队列的定义及特点栈(Stack)是一种后进先出(Last In First Out,LIFO)的数据结构,它只允许在一端进行插入和删除操作。

栈的典型应用场景有函数调用、递归算法等。

队列(Queue)是一种先进先出(First In First Out,FIFO)的数据结构,它允许在两端进行插入和删除操作。

队列的典型应用场景有打印队列、任务队列等。

2. 栈和队列的存储结构(1)顺序存储结构栈和队列的顺序存储结构使用数组来实现。

对于栈,通常使用数组的一端作为栈顶,入栈操作在栈顶进行,出栈操作也在栈顶进行。

对于队列,通常使用数组的一端作为队首,入队操作在队尾进行,出队操作在队首进行。

(2)链式存储结构栈和队列的链式存储结构使用链表来实现。

对于栈,每个元素节点包含数据和指向下一个节点的指针。

入栈操作在链表头部进行,出栈操作在链表头部进行。

对于队列,每个元素节点包含数据和指向下一个节点的指针。

入队操作在链表尾部进行,出队操作在链表头部进行。

3. 栈和队列的基本操作(1)栈的基本操作- 入栈(push):将元素添加到栈顶。

- 出栈(pop):从栈顶删除元素。

- 获取栈顶元素(peek):获取栈顶元素,但不删除它。

- 判断栈空(isEmpty):判断栈是否为空。

(2)队列的基本操作- 入队(enqueue):将元素添加到队列尾部。

- 出队(dequeue):从队列头部删除元素。

- 获取队首元素(peek):获取队首元素,但不删除它。

数据结构实验报告栈及其应用docx

数据结构实验报告栈及其应用docx

引言概述:正文内容:一、栈的概念和基本特性1.1栈的定义栈是一种操作受限的线性表,只允许在一端进行插入和删除操作,该端称为栈顶,另一端称为栈底。

栈的特点是“后进先出”(LIFO,LastInFirstOut)。

1.2栈的基本操作栈包含几个基本操作,如入栈(Push)、出栈(Pop)、判空(IsEmpty)、判满(IsFull)等。

二、栈的顺序存储结构实现方式2.1顺序存储结构的定义栈的顺序存储结构是利用一组地质连续的存储单元依次存储栈中的元素。

数组可以作为栈的顺序存储结构进行实现。

2.2顺序存储结构的入栈操作入栈操作需要将新元素插入栈顶,并更新栈顶指针。

2.3顺序存储结构的出栈操作出栈操作需要删除栈顶元素,并更新栈顶指针。

三、栈的链式存储结构实现方式3.1链式存储结构的定义栈的链式存储结构是利用链表实现栈的存储结构。

每个链表节点包含存储元素的数据域和指向下一个节点的指针域。

3.2链式存储结构的入栈操作入栈操作需要创建一个新节点并插入到链表头部,并更新栈顶指针。

3.3链式存储结构的出栈操作出栈操作需要删除链表头节点,并更新栈顶指针。

四、栈的应用4.1递归算法栈常用于实现递归算法,通过将递归函数的参数和局部变量保存在栈中,实现递归函数的调用和返回。

4.2括号匹配栈可以判断表达式中的括号是否匹配,通过入栈和出栈操作进行括号的匹配过程。

4.3后缀表达式求值栈可以用来实现后缀表达式的求值过程,通过入栈和出栈操作计算后缀表达式的值。

五、总结本文详细讨论了栈的概念、特性、实现方式和应用。

通过了解栈的基本操作,我们可以更好地理解栈的原理和使用。

栈在计算机科学领域具有广泛的应用,对于实现递归算法、括号匹配和后缀表达式求值等问题都有重要作用。

对于进一步的学习和实践,我们需要深入理解栈的原理和实现方式,并能熟练运用栈解决问题。

希望本文能为读者对栈及其应用有一个清晰的认识。

栈的应用实验报告

栈的应用实验报告

栈的应用实验报告栈的应用实验报告引言:栈是一种常见的数据结构,它具有后进先出(Last In First Out,LIFO)的特点。

在计算机科学中,栈被广泛应用于各种领域,如编译器、操作系统、图形处理等。

本实验旨在通过实际应用场景,探索栈的应用。

一、栈的基本概念和操作栈是一种线性数据结构,它由一系列元素组成,每个元素都有一个前驱元素和一个后继元素。

栈的基本操作包括入栈(Push)和出栈(Pop)。

入栈将元素添加到栈的顶部,而出栈则将栈顶元素移除。

此外,栈还具有查看栈顶元素(Top)和判断栈是否为空(IsEmpty)的操作。

二、栈在表达式求值中的应用栈在表达式求值中发挥着重要作用。

例如,当我们需要计算一个数学表达式时,可以通过将表达式转换为后缀表达式,并利用栈来进行求值。

栈中存储操作数,当遇到运算符时,从栈中弹出相应数量的操作数进行计算,再将结果入栈。

通过这种方式,我们可以实现高效的表达式求值。

三、栈在函数调用中的应用栈在函数调用中也扮演着重要角色。

当我们调用一个函数时,计算机会将函数的返回地址、参数和局部变量等信息存储在栈中。

这样,当函数执行完毕后,可以从栈中恢复之前的上下文,继续执行调用函数的代码。

栈的这种特性使得递归函数的实现成为可能,同时也为程序的模块化提供了便利。

四、栈在迷宫求解中的应用栈在迷宫求解中也能发挥重要作用。

当我们需要找到从起点到终点的路径时,可以利用栈来存储当前路径上的位置。

从起点开始,我们按照某种策略选择下一个位置,并将其入栈。

如果当前位置无法继续前进,则将其出栈,并选择下一个位置。

通过不断重复这个过程,直到找到终点或者栈为空,我们就能得到迷宫的解。

五、栈在撤销和恢复操作中的应用栈在撤销和恢复操作中也能发挥重要作用。

当我们在编辑文档或者绘图时,经常需要进行撤销和恢复操作。

栈可以用来记录每次操作的状态,当用户选择撤销时,从栈中弹出最近的操作,并将文档或图形恢复到之前的状态。

通过这种方式,我们可以提供良好的用户体验,同时也方便用户进行操作的回溯。

实验2 栈及其应用

实验2 栈及其应用

实验二栈及其应用1.实验目的(1)掌握栈的特点及其描述方法。

(2)用链式存储结构实现一个栈。

(3)掌握建栈的各种等基本操作。

(4)掌握栈的几个典型应用的算法。

2.实验内容A.验证性部分(1)设计一个字符型的链栈;(2)编写进栈、出栈、显示栈中全部元素的程序;(3)编写一个把十进制整数转换成二进制数的应用程序;(4)设计一个选择式菜单,以菜单方式选择上述操作。

B.自主性实验部分(1)用键盘输入一个整数后缀表达式(操作数的范围是0~9,运算符只含+、-、*、/,而且中间不可以有空格),使用循环程序从左向右读入表达式。

(2)如果读入的是操作数,直接进入操作数栈。

(3)如果读入的是运算符,立即从操作数栈取出所需的操作数,计算操作数运算的值,并将计算结果存回操作数栈。

3.实验要求:(1)选择合适的存储结构(顺序栈或链式栈)表示栈,给出其定义。

(2)在上述存储结构上实现栈的基本操作:初始化、置栈空、入栈、出栈、取栈顶元素等。

(3)分析后缀表达式求值的算法思想,用C(或C++)语言设计程序。

(4)上机调试通过实验程序。

(5)给出具体的算法分析,包括时间复杂度和空间复杂度等。

(6)撰写实验报告。

4.实验预备知识(1)栈的定义及栈的“后进先出”的特点。

(2)栈的顺序存储与链式存储结构及栈的初始化、入栈、出栈、取栈顶等基本操作。

(3)算术表达式的三种表示形式(前缀式、中缀式、后缀式)。

5.实验环境(1)一台运行 Windows 2000/XP 操作系统的计算机(2)选用turbo c或visual c++6、实验说明(1)类型定义#define MAXSIZE 100 /*栈的最大值*/typedef struct{ElemType elem[MAXSIZE];int top;}SqStack; /*顺序栈的类型定义*/(2)注意问题①重点理解栈的算法思想,能够根据实际情况选择合适的存储结构②栈的算法是后续实验的基础(广义表、树、图、查找、排序等)7.实验用测试数据和相关结果分析:(由学生填写)8.实验总结:(由学生填写)9.参考程序参考模板A.验证性实验程序模板#include <stdio.h>#include <stdlib.h>#include “链栈.h”#define MAXLEN 100void main(){int i=1,j=1,choice,val,n;char a;linkstack *s=new linkstack;s->top=NULL;while(i){printf("\n\n");printf("\n\t\t 链栈子系统\n");printf("\n\t\t*******************************");printf("\n\t\t* 1----入栈*");printf("\n\t\t* 2----出栈*");printf("\n\t\t* 3----显示栈*");printf("\n\t\t* 4----进制转换*");printf("\n\t\t* 0----返回*");printf("\n\t\t*******************************");printf("\n\t\t 请选择(0--4):");choice=getchar();getchar();switch (choice){case '1':while(j){printf("\t\t请输入一个整数(按回车输入下一个,输入'0'结束):");scanf("%d",&val);getchar();if (val!=0)push(s,val);elsej=0;}break;case '2':if(s->top!=NULL) printf("出栈元素是:%6d\n",pop(s));break;case '3': showstack(s);break;case '4':printf("请输入待转换的数'n' 和进制'i':(n,i)\n");scanf("%d,%d",&n,&i);Conversion(i,n);break;case '0':i=0;break;default:;}if (choice=='1'||choice=='2'||choice=='3'||choice=='4'){printf("\n\t\t按回车键继续,按其它任意键返回!");a=getchar();if (a!='\xA')i=0;}}system("pause");}/*链栈头文件:链栈.h*/typedef char datatype;typedef struct stacknode{int data;struct stacknode *next;}stacknode;typedef struct{stacknode *top;}linkstack;void push(linkstack *s,int x) /*进栈*/{//请补充完善}int pop(linkstack *s) /*出栈*/{//请补充完善}void showstack(linkstack *s) /*显示栈元素*/{//请补充完善}void Conversion(int i,int n) /*进制转换*/{//请补充完善}B.自主性实验程序模板/*表达式求值程序*/#include"stdio.h"#include "stdlib.h"#include"string.h"#define MAXSIZE 100typedef char ElemType;#include "顺序栈.h"char operate(char a,char theta,char b) /*求两数a和b作θ运算的结果*/{int r;a=a-48;b=b-48;switch(theta){case '+':r=a+b;break;case '-':r=a-b;break;case '*':r=a*b;break;case '/':r=a/b;break;}return(r+48);}char precede(char theta1,char theta2) /*判断两个运算符θ1和θ2的优先关系*/{switch(theta1){case '+':case '-':{if(theta2=='+'||theta2=='-'||theta2==')'||theta2=='#')return('>');else if(theta2=='*'||theta2=='/'||theta2=='(')return('<');}case '*':case '/':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2==')'||theta2=='#')return('>');else if(theta2=='(')return('<');}case '(':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2=='(')return('<');else if(theta2==')')return('=');}case ')':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2==')'||theta2=='=')return('>');}case '=':{if(theta2=='+'||theta2=='-'||theta2=='*'||theta2=='/'||theta2=='(')return('<');else if(theta2=='=')return('=');}}}char Evaluation(char exp[20])/*返回由中缀式exp表示的算术表达式的运算结果。

数据结构实验报告(栈

数据结构实验报告(栈

数据结构实验报告(栈
一、实验名称
栈的实现及应用
二、实验目的
1.了解栈的概念与基本操作。

2.掌握栈的基本实现(栈的存储结构、栈的主要操作和栈的应用)。

3.通过编写程序实现栈的基本操作和应用。

三、实验内容
1.栈的定义:栈是一种具有特定结构的数据类型,其特殊之处在于只能从固定的一端(称为栈顶)进行插入,删除和查找操作。

2.栈的存储结构:栈既可以采用顺序存储结构,也可以采用链式存储结构。

3.栈的基本操作有:进栈(push)、出栈(pop)、查看栈顶元素(get_top)、清空栈(clear)、获取栈长度(length)等。

4.栈的应用:主要用于表达式求值、括号匹配、逆序输出等操作。

五、实验步骤
2.编写程序实现栈结构的创建、进栈、出栈、查看栈顶元素、清空栈、获取栈长度等基本操作。

四、实验结果
1.按照实验要求,成功创建一个栈的数据结构,并实现栈的基本操作。

栈作为常用的一种数据结构,在实际的编程中有广泛的应用。

通过本次实验的学习,对栈的概念、特点、实现方式有了更深刻的了解,同时也掌握了栈的一些应用操作,这对于提高代码效率和解决实际问题有很大的帮助。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构栈实验报告

数据结构栈实验报告

一、实验目的本次实验旨在帮助学生掌握栈的基本概念、特点、逻辑结构以及抽象数据类型,熟练运用顺序栈和链栈进行基本操作,理解递归算法中栈的状态变化,并学会在计算机科学中应用栈解决实际问题。

二、实验内容1. 实现顺序栈和链栈的结构类型定义、特点以及基本操作的实现。

2. 编写算法判断给定字符序列是否为回文。

3. 设计算法,利用栈操作将指定栈中的内容进行逆转。

4. 实现求解整数数组最大值的递归算法。

5. 分析实验过程中遇到的问题及解决方法。

三、实验步骤1. 实现顺序栈和链栈(1)顺序栈顺序栈使用数组实现,具有以下特点:- 存储空间固定,栈的大小预先定义。

- 栈顶指针指示栈顶元素的位置。

- 入栈和出栈操作都在栈顶进行。

- 当栈满时,无法继续入栈。

- 当栈空时,无法继续出栈。

(2)链栈链栈使用链表实现,具有以下特点:- 栈的大小可变,不受存储空间限制。

- 栈顶指针指向栈顶元素的前一个节点。

- 入栈和出栈操作的时间复杂度为O(1)。

- 不存在栈满或栈空的情况。

2. 编写算法判断字符序列是否为回文(1)创建一个空栈。

(2)遍历字符序列,将每个字符依次入栈。

(3)遍历字符序列,将每个字符依次出栈,并判断出栈的字符是否与原序列中的字符相同。

(4)若所有字符均相同,则字符序列为回文;否则,不是回文。

3. 设计算法,利用栈操作将指定栈中的内容进行逆转(1)创建一个空栈。

(2)遍历原栈,将每个元素依次出栈,并判断栈是否为空。

(3)若栈不为空,则将出栈的元素依次入栈。

(4)当原栈为空时,将新栈中的元素依次出栈,实现栈内容的逆转。

4. 实现求解整数数组最大值的递归算法(1)定义一个递归函数,用于求解数组中最大值。

(2)在递归函数中,比较当前元素与左右子数组中的最大值。

(3)返回最大值。

5. 分析实验过程中遇到的问题及解决方法(1)问题:顺序栈在栈满时无法继续入栈。

解决方法:在入栈操作前,判断栈的大小是否已满。

若已满,则提示用户栈已满,无法继续入栈。

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

《算法与数据结构》课程实验报告一、实验目的1.熟悉栈的特点(先进后出)及栈的基本操作,如入栈、出栈等,掌握栈的基本操作在栈的顺序存储结构。

2.实现栈的顺序存储结构,通过实验深入理解栈的操作特点。

二、实验内容及要求1.实现栈的存储结构及相关操作:进栈、出栈、取栈顶元素等。

2.使用该栈完成对一个字符串的逆序输出。

3.使用该栈完成判断表达式的括号是否匹配。

4.对算术表达式求值。

三、系统分析(1)数据方面:该栈数据元素类型采用浮点型,在此基础上进行栈的基本操作,并可将栈中数据使用文本文档保存。

在栈的应用中,采用的是存储字符元素类型的栈,并进行对字符的相关操作。

(2)功能方面:能实现栈的一些基本操作,主要包括:1.进栈操作:若栈不满,则将元素x插入至栈的栈顶,若栈满则进行溢出处理。

2.出栈操作:若栈不空,则函数返回该栈栈顶的元素,并且栈顶指针退1。

3.获取栈顶元素:若栈不空,则函数返回栈顶元素。

4.判断栈是否为空、判断栈是否满。

5.计算栈中元素个数:直接返回栈中元素个数。

6.清空栈内容:将栈顶指针赋为初始值。

7.保存数据:将栈中元素数据保存至文本文档中。

四、系统设计(1)设计的主要思路顺序栈可以采用顺序表作为其存储表示,为此,在顺序栈的声明中用顺序表定义它的存储空间。

存放栈元素的数组的头指针为*elements,该数组最大能允许存放元素个数为maxSize,当前栈顶位置由数组下标指针top知识。

并规定如果栈不空时,elements[0]为栈中第一个元素。

由于实验中还需完成栈的相关应用,故使用两个菜单分别完成栈的基本操作与栈的应用调试。

(2)数据结构的设计顺序栈定义为只允许在表的末端进行插入和删除的线性表。

允许插入和删除的一端叫做栈顶,而不允许插入和删除的另一端叫做栈底。

当栈中没有任何元素时则成为空战。

即栈又被称为后进先出的线性表,故与线性表的相关操作类似,在此基础上完成栈的相关操作及应用。

数据结构设计思路(3)基本操作的设计栈的基本操作主要包括进栈、出栈、弹出栈顶元素等。

主要难点是在栈相关应用的实现。

第一个应用即是通过栈的操作实现括号匹配。

思路则是依次扫描输入字符串,将左括号存放至栈中,后续扫描遇到右括号则与之相匹配,同时在栈顶删除左括号。

最后将括号匹配信息输出。

在实现栈进行表达式计算过程稍微复杂。

先编写一个Calculator类,该类实现表达式计算的进操作数、退操作数等操作,在主函数文件中编写将中缀表达式转为后缀表达式函数,将转化后的表达式在进行计算即可。

算法主要思路为:顺序扫描表达式每一项,如果是操作数则进行压栈,为操作符则弹出两个操作数,并进行指令运算,将结果再次压入栈中,处理完后,将结果输出即可。

由于为了实现多为操作数的计算故需作出相应改进,用一个字符串保存输入的表达式,在通过字符串操作将操作数和操作符保存至一个字符串数组中,再通过栈的操作将其转为后缀表达式并存放至字符串数组中,在在字符串数组的基础上进行表达式值得计算。

该函数可计算操作数为双精度的表达式。

五、编程环境与实验步骤(1)编程环境操作系统:Windows操作系统;编程工具软件:Visual Studio 2017(2)实验步骤程序相关文件为SeqStack模板类文件、Calculator类文件、以及主函数调试文件main.cpp。

Calculator类文件在栈应用操作中实现表达式相关计算,SeqStack 模板类文件包括栈的相关操作,例如进栈、出栈等操作。

主函数调试文件则是用于调试栈的基本操作,并且添加了相关栈应用的相关函数,可通过两个菜单的关联,完成栈的基本操作以及相关应用的实现。

(3)编译参数无编译参数,在Vs2017或其他版本中新建项目然后将三个文件main.cpp、Calculator.h、SeqStack.h添加到解决方案中的头文件中调试即可。

六、实现代码#include<iostream>#include"Calculator.h"#include<string>using namespace std;const int maxLength = 100; //最大匹配字符串长度int isp(char &a);//栈内优先数int icp(char &a);//栈外优先数void PrintMatchedPairs(char *expression);//栈的应用——括号匹配void postfix();//栈的应用——中缀表达式转化为后缀表达式void inverse(char *c);//栈的应用——字符串逆序输出void menu1();//栈的基本操作菜单void menu2();//栈的应用菜单string str2[1000];//用于存放中缀表达式int number = 0;//用于表示表达式中数据个数int main() {int fini = 0; int choose;while (!fini) {cout <<"***************************************"<< endl;cout <<"-----------1、栈的基本操作-------------"<< endl;cout <<"-----------2、栈的应用-----------------"<< endl;cout <<"-----------3、退出---------------------"<< endl;cout <<"***************************************"<< endl;cout <<"请输入你的选择[1-3]:"<< endl;cin >> choose;switch (choose) {case 1:menu1();break;case 2:menu2();break;case 3:fini = 1;break;default:cout <<"输入选择错误,请重新输入!"<< endl;}}return 0;}int isp(char &a) {switch (a) {case'#':return 0; break;case'(':return 1; break;case'*':case'%':case'/':return 5; break;case'+':case'-':return 3; break;case')':return 6; break;}}int icp(char &a) {switch (a) {case'#':return 0; break;case'(':return 6; break;case'*':case'%':case'/':return 4; break;case'+':case'-':return 2; break;case')':return 1; break;}}void PrintMatchedPairs(char *expression) {SeqStack<int> s(maxLength);int j, length = strlen(expression);for (int i = 1; i <=length; i++) {if (expression[i - 1] == '(')s.Push(i);else if (expression[i - 1] == ')') {if (s.Pop(j) == true)cout << j <<"与"<< i <<"匹配"<< endl;elsecout <<"没有与第"<< i <<"个右括号匹配的左括号!"<< endl;}}while (s.IsEmpty() == false) {s.Pop(j);cout <<"没有与第"<< j <<"个左括号匹配的右括号!"<< endl;}}void postfix() {SeqStack<char> s;char ch = '#';s.Push(ch);string str ; //用于存放表达式string num = "";//用于存放有多位的操作数cout <<"请输入表达式:"<< endl; cin >> str;for (int i = 0; i < str.length(); i++){if (str[i] == '0' || str[i] == '1' || str[i] == '2' || str[i] == '3' || str[i] == '4' || str[i] == '5' || str[i] == '6' || str[i] == '7' || str[i] == '8' || str[i] == '9' || str[i] == '.') {num = num + str[i];}else {char ch1;str2[number] = num; number++; num ="";s.getTop(ch1);if (isp(ch1) < icp(str[i])) {s.Push(str[i]);}else if (isp(ch1) > icp(str[i])) {char op;s.Pop(op);if (op != '(') {str2[number] = op; number++; i--;}}else {char ch3;s.Pop(ch3);}}}if (num !="") {str2[number] = num; number++; num ="";}while (!s.IsEmpty()){char ch4; s.Pop(ch4); str2[number] = ch4; number++;}}void inverse(char *c) {SeqStack<char> s; int i = 0; char ch;int l = strlen(c);for (int i = 0; i < l; i++)s.Push(c[i]);for (int i = 0; i < l; i++) {s.Pop(ch);cout << ch <<" ";}}void menu1() {int fini = 0; int choose;SeqStack<double> s;double x;//压栈元素double y;//存储出栈元素double z;//存储栈顶元素while (!fini) {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;cout <<"****************************************"<< endl;cout <<"请输入你的选择[1-9]:"<< endl;cin >> choose;switch (choose) {case 1:cout <<"输入进栈数:"<<endl;cin >> x;s.Push(x);break;case 2:s.Pop(y);cout <<"弹出元素是:"<< y << endl;break;case 3:s.getTop(z);cout <<"此时栈顶元素为:"<< z << endl;break;case 4:if (s.IsEmpty())cout <<"栈为空!"<< endl;elsecout <<"栈不为空!"<< endl;break;case 5:if(s.IsFull())cout <<"栈满!"<< endl;elsecout <<"栈不满!"<< endl;break;case 6:cout <<"此时栈中有"<< s.getSize() <<"个元素"<< endl;break;case 7:s.MakeEmpty();cout <<"栈被清空"<< endl;case 8:s.SaveFile();cout <<"保存成功!(数据由顶至底)"<< endl;cout <<"此时栈被清空!"<< endl;break;case 9:fini = 1;break;default:cout <<"输入选择错误,请重新输入!"<< endl;}}}void menu2() {int fini = 0; int choose;char c[maxLength];//输入字符串double x;Calculator ca(stackIncreament);while (!fini) {cout <<"-----------二、栈的应用-----------------"<< endl;cout <<"-----------1:括号匹配-------------------"<< endl;cout <<"-----------2:表达式的计算---------------"<< endl;cout <<"-----------3:字符串逆序输出-------------"<< endl;cout <<"-----------4:退出:---------------------"<< endl;cout <<"****************************************"<< endl;cout <<"请输入你的选择[1-4]:"<< endl;cin >> choose;switch (choose) {case 1:cin.get();cin.getline(c,maxLength);PrintMatchedPairs(c);break;case 2:postfix();ca.Run(x);cout << x << endl;break;case 3:cin.get();cin.getline(c, maxLength);cout <<"字符串逆序输出:"<< endl;inverse(c);cout << endl;break;case 4:fini = 1;break;default:cout <<"输入选择错误,请重新输入!"<< endl;}}}七、测试结果与说明栈的基本操作:进栈与出栈:进栈与读取元素:栈中元素个数:栈空或满:保存数据:栈的相关应用:字符串中括号匹配:字符串逆序输出:表达式计算:八、实验分析(1)算法的性能分析栈的括号匹配算法分析。

相关文档
最新文档