栈的操作(实验报告)
栈的实验报告结论(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）测试程序：验证了栈在程序设计中的应用。
栈的实验报告
栈的实验报告一、实验目的本次实验的主要目的是深入理解栈这种数据结构的基本概念和操作原理，并通过实际编程实现来巩固对栈的特性和应用的掌握。
二、实验环境本次实验使用的编程语言为C+＋，编程环境为Visual Studio 2019。
三、实验原理栈（Stack）是一种特殊的线性表，其操作遵循“后进先出”（Last In First Out，LIFO）的原则。
栈只允许在表的一端进行插入和删除操作，这一端被称为栈顶（Top），另一端则被称为栈底（Bottom）。
栈的基本操作包括：1、｀Push`（入栈）：将元素添加到栈顶。
2、｀Pop`（出栈）：删除并返回栈顶元素。
3、｀Top`（获取栈顶元素）：返回栈顶元素，但不删除它。
4、｀IsEmpty`（判断栈是否为空）：如果栈为空，返回｀true`，否则返回｀false`。
四、实验内容与步骤1、定义栈的数据结构｀｀｀cppclass Stack ｛private:int stackArray;int top;int capacity;public:Stack(int size) ｛capacity ＝ size;stackArray ＝ new intcapacity; top ＝－1;｝～Stack(）｛delete stackArray;｝void Push(int element) ｛if （top ＝＝ capacity 1) ｛std:：cout ＜＜＂Stack Overflow!＂＜＜ std:：endl; return;｝stackArray+＋top ＝ element;｝int Pop(）｛if （IsEmpty(））｛std:：cout ＜＜＂Stack Underflow!＂＜＜ std:：endl; return －1;｝int element ＝ stackArraytop;stackArraytop ＝ 0;return element;｝int Top(）｛if （IsEmpty(））｛std:：cout ＜＜＂Stack is empty!＂＜＜ std:：endl; return －1;｝return stackArraytop;｝bool IsEmpty(）｛return top ＝＝－1;｝void PrintStack(）｛for （int i ＝ top; i ＞＝ 0; i) ｛std:：cout ＜＜ stackArrayi ＜＜＂＂；｝std:：cout ＜＜ std:：endl;｝｝；｀｀｀2、测试栈的基本操作｀｀｀cppint main(）｛Stack stack(5)；stackPush(10)；stackPush(20)；stackPush(30)；std:：cout ＜＜＂Top element: ＂＜＜ stackTop(）＜＜ std:：endl;stackPop(）；std:：cout ＜＜＂Top element after pop: ＂＜＜ stackTop(）＜＜std:：endl;stackPrintStack(）；return 0;｝｀｀｀五、实验结果与分析在实验过程中，我们成功地实现了栈的基本操作，并对其进行了测试。
栈和队列基本操作实验报告
栈和队列基本操作实验报告实验目的1. 了解栈和队列的基本概念和特点；2. 掌握栈和队列的基本操作，包括插入、删除、判空、判满等；3. 加深对数据结构的理解，提高编程能力。
实验原理1. 栈(Stack)是一种“先进后出”(Last In First Out，简称LIFO)的数据结构，类似于一摞盘子，最先放入的盘子在最底下，最后放入的盘子在最上面，取出盘子时也是从上往下取出。
2. 队列(Queue)是一种“先进先出”(First In First Out，简称FIFO)的数据结构，类似于排队，先来的人先进队列，后来的人排在后面，服务员按照队列顺序依次为每个人提供服务。
实验内容1. 栈的实现栈的基本操作包括入栈(push)、出栈(pop)、判空(empty)、栈顶(top)。
本次实验选择使用顺序栈来实现，并通过代码模拟栈的基本操作。
在顺序栈的实现中，需要设置栈顶指针(top)、初始化栈、入栈、出栈、判空、判满等操作，其中最关键的是入栈和出栈操作。
入栈操作：在栈顶指针(top)的位置加1，将元素e放到栈顶```void push(SqStack &s, ElemType e){if (s.top == MAXSIZE - 1) // 栈满return;s.top++; // 栈顶指针加1s.data[s.top] = e; // 将元素e放到栈顶return;}```出队操作：将队头元素弹出，队头指针(front)加1实验结果1. 栈的实现通过栈的实现，我们可以进行压入和弹出元素的操作。
下面是一段示例代码：通过本次实验，我学会了栈和队列的基本概念和特点，掌握了栈和队列的基本操作，如插入、删除、判空、判满等。
这些基本操作是数据结构中的重要部分，对于算法的实现与性能优化都有很大的帮助。
此外，在实现中，我们还需要注意栈和队列指针的变化，以及对于空栈和空队列的处理。
通过本次实验，我加深了对数据结构的理解，同时也提升了编程能力。
栈及其应用实验报告
一、实验目的1. 理解栈的定义、特点、逻辑结构及其在计算机科学中的应用。
2. 掌握顺序栈和链栈的存储结构及基本操作实现。
3. 通过具体应用实例，加深对栈的理解，提高问题分析和解决的能力。
二、实验内容1. 实现顺序栈和链栈的基本操作。
2. 编写一个算法，判断给定的字符序列是否为回文。
3. 编写一个算法，利用栈的基本运算将指定栈中的内容进行逆转。
4. 给定一个整数序列，实现一个求解其中最大值的递归算法。
三、实验步骤1. 实现顺序栈和链栈的基本操作（1）顺序栈的存储结构及操作实现顺序栈使用数组来实现，其基本操作包括：- 初始化栈：使用数组创建一个空栈，并设置栈的最大容量。
- 入栈：将元素插入栈顶，如果栈满，则返回错误。
- 出栈：从栈顶删除元素，如果栈空，则返回错误。
- 获取栈顶元素：返回栈顶元素，但不删除。
- 判断栈空：判断栈是否为空。
（2）链栈的存储结构及操作实现链栈使用链表来实现，其基本操作包括：- 初始化栈：创建一个空链表，作为栈的存储结构。
- 入栈：在链表头部插入元素，如果链表为空，则创建第一个节点。
- 出栈：删除链表头部节点，如果链表为空，则返回错误。
- 获取栈顶元素：返回链表头部节点的数据。
- 判断栈空：判断链表是否为空。
2. 判断字符序列是否为回文编写一个算法，判断给定的字符序列是否为回文。
算法步骤如下：（1）使用顺序栈或链栈存储字符序列。
（2）从字符序列的头部开始，依次将字符入栈。
（3）从字符序列的尾部开始，依次将字符出栈，并与栈顶元素比较。
（4）如果所有字符均与栈顶元素相等，则字符序列为回文。
3. 利用栈的基本运算将指定栈中的内容进行逆转编写一个算法，利用栈的基本运算将指定栈中的内容进行逆转。
算法步骤如下：（1）创建一个空栈，用于存储逆转后的栈内容。
（2）从原栈中依次将元素出栈，并依次入新栈。
（3）将新栈的内容赋值回原栈，实现栈内容的逆转。
4. 求解整数序列中的最大值给定一个整数序列，实现一个求解其中最大值的递归算法。
栈的建立实验报告
一、实验目的本次实验旨在通过编程实现栈的顺序存储结构和链式存储结构，并熟练掌握栈的基本操作，包括栈的建立、入栈、出栈、取栈顶元素、判栈空等。
通过实验，加深对栈这一数据结构的理解，提高数据结构在实际问题中的应用能力。
二、实验内容1. 顺序栈的建立与基本操作（1）顺序栈的建立顺序栈使用一维数组来实现，其大小为栈的最大容量。
在建立顺序栈时，需要初始化栈顶指针top为-1，表示栈为空。
（2）顺序栈的基本操作① 入栈操作（Push）当栈未满时，将新元素插入到栈顶，同时栈顶指针top加1。
② 出栈操作（Pop）当栈非空时，将栈顶元素出栈，同时栈顶指针top减1。
③ 取栈顶元素操作（GetTop）当栈非空时，返回栈顶元素。
④ 判栈空操作（IsEmpty）当栈顶指针top为-1时，表示栈为空。
2. 链式栈的建立与基本操作（1）链式栈的建立链式栈使用链表来实现，每个节点包含数据域和指针域。
在建立链式栈时，需要创建一个头节点，其指针域为空。
（2）链式栈的基本操作① 入栈操作（Push）当栈为空时，创建新节点作为栈顶节点；当栈非空时，将新节点插入到头节点的下一个节点，同时修改头节点的指针域。
② 出栈操作（Pop）当栈非空时，删除头节点的下一个节点，同时修改头节点的指针域。
③ 取栈顶元素操作（GetTop）当栈非空时，返回头节点的下一个节点的数据域。
④ 判栈空操作（IsEmpty）当头节点的指针域为空时，表示栈为空。
三、实验步骤1. 编写顺序栈和链式栈的建立函数。
2. 编写顺序栈和链式栈的基本操作函数。
3. 编写测试程序，验证顺序栈和链式栈的基本操作。
四、实验结果与分析1. 顺序栈实验结果通过编写顺序栈的建立和基本操作函数，成功实现了顺序栈的入栈、出栈、取栈顶元素、判栈空等操作。
在测试程序中，依次进行入栈、出栈、取栈顶元素等操作，均能正确执行。
2. 链式栈实验结果通过编写链式栈的建立和基本操作函数，成功实现了链式栈的入栈、出栈、取栈顶元素、判栈空等操作。
栈的基本操作实验报告
一、实验目的1. 掌握栈的定义、特点、逻辑结构，理解栈的抽象数据类型。
2. 熟练掌握顺序栈和链栈两种结构类型的定义、特点以及基本操作的实现方法。
3. 了解栈在解决实际问题中的应用。
二、实验内容1. 编写顺序栈和链栈的基本操作函数，包括入栈（push）、出栈（pop）、判断栈空（isEmpty）、获取栈顶元素（getTop）等。
2. 利用栈实现字符序列是否为回文的判断。
3. 利用栈实现整数序列中最大值的求解。
三、实验步骤1. 创建顺序栈和链栈的结构体，并实现相关的基本操作函数。
2. 编写一个函数，用于判断字符序列是否为回文。
该函数首先将字符序列中的字符依次入栈，然后逐个出栈，比较出栈的字符是否与原序列相同，若相同则表示为回文。
3. 编写一个函数，用于求解整数序列中的最大值。
该函数首先将序列中的元素依次入栈，然后逐个出栈，每次出栈时判断是否为当前栈中的最大值，并记录下来。
四、实验结果与分析1. 顺序栈和链栈的基本操作函数实现如下：```c// 顺序栈的基本操作void pushSeqStack(SeqStack s, ElemType x) {if (s->top < MAXSIZE - 1) {s->top++;s->data[s->top] = x;}}void popSeqStack(SeqStack s, ElemType x) {if (s->top >= 0) {x = s->data[s->top];s->top--;}}bool isEmptySeqStack(SeqStack s) {return s->top == -1;}ElemType getTopSeqStack(SeqStack s) {if (s->top >= 0) {return s->data[s->top];}return 0;}// 链栈的基本操作void pushLinkStack(LinkStack s, ElemType x) {LinkStack p = (LinkStack )malloc(sizeof(LinkStack)); if (p == NULL) {exit(1);}p->data = x;p->next = s->top;s->top = p;}void popLinkStack(LinkStack s, ElemType x) { if (s->top != NULL) {LinkStack p = s->top;x = p->data;s->top = p->next;free(p);}}bool isEmptyLinkStack(LinkStack s) {return s->top == NULL;}ElemType getTopLinkStack(LinkStack s) {if (s->top != NULL) {return s->top->data;}return 0;}```2. 判断字符序列是否为回文的函数实现如下：```cbool isPalindrome(char str) {SeqStack s;initStack(&s);int len = strlen(str);for (int i = 0; i < len; i++) {pushSeqStack(&s, str[i]);}for (int i = 0; i < len; i++) {char c = getTopSeqStack(&s);popSeqStack(&s, &c);if (c != str[i]) {return false;}}return true;}```3. 求解整数序列中最大值的函数实现如下：```cint getMax(int arr, int len) {LinkStack s;initStack(&s);int max = arr[0];for (int i = 0; i < len; i++) {pushLinkStack(&s, arr[i]);if (arr[i] > max) {max = arr[i];}}while (!isEmptyLinkStack(&s)) {popLinkStack(&s, &max);}return max;}```五、实验心得通过本次实验，我对栈的基本操作有了更深入的理解。
数据结构实验报告栈
数据结构实验报告：栈摘要：本实验报告旨在介绍栈这一重要的数据结构，以及在实际应用中的使用。
栈是一种先进后出（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.撤销操作使用栈来实现撤销操作的原理和过程在编辑器、图形处理软件等领域的实际应用总结：本文详细介绍了栈的操作，包括基本操作（压栈、弹栈、获取栈顶元素、判断栈是否为空、栈的大小）和应用场景（括号匹配、浏览器的后退和前进功能、函数调用和递归、实现浏览器缓存、撤销操作）。
通过了解栈的操作和应用，我们可以更好地理解数据结构中的栈，并能够在实际问题中灵活运用栈的特性。
栈的基本操作实验报告
栈的基本操作实验报告实验目的本实验旨在通过使用栈来实现基本的操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。
实验原理栈是一种后进先出（Last-In-First-Out）的数据结构，类似于我们平常生活中的堆栈。
栈有两个基本操作：入栈（Push）和出栈（Pop）。
•入栈：将一个元素放入栈的顶部，使其成为新的栈顶元素。
•出栈：移除栈顶元素，并返回该元素的值。
•查看栈顶元素：返回栈顶元素的值，但不将其从栈中移除。
•判断栈是否为空：若栈中没有元素，则栈为空。
实验步骤以下是使用Python语言来实现栈基本操作的步骤。
1. 创建一个空栈首先，我们需要创建一个空栈。
可以使用列表（List）来模拟栈的操作。
例如：stack = []2. 入栈操作接下来，我们可以通过使用append()函数将元素添加到栈的顶部来进行入栈操作。
例如，我们将数字1和2入栈：stack.append(1)stack.append(2)此时栈的内容为：[1, 2]，其中2为栈顶元素。
3. 出栈操作要进行出栈操作，我们可以使用pop()函数。
该函数会移除并返回栈顶元素的值。
例如：value = stack.pop()print(value) # 输出：2此时栈的内容为：[1]，其中1为新的栈顶元素。
4. 查看栈顶元素要查看栈顶元素的值，我们可以使用索引-1来访问栈的最后一个元素。
例如：value = stack[-1]print(value) # 输出：1此时栈的内容仍为：[1]，其中1为栈顶元素。
5. 判断栈是否为空要判断栈是否为空，我们可以使用条件语句结合len()函数来判断栈的长度是否为0。
例如：if len(stack) ==0:print("栈为空")else:print("栈不为空")由于栈中还有一个元素1，所以输出为“栈不为空”。
实验总结通过本实验，我们学习了栈的基本操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。
栈类的实验报告
一、实验目的1. 了解栈类的基本概念和原理；2. 掌握栈类的实现方法；3. 提高编程能力和数据结构应用能力。
二、实验环境1. 操作系统：Windows 10；2. 编程语言：Java；3. 开发工具：Eclipse。
三、实验原理栈（Stack）是一种后进先出（Last In First Out，LIFO）的数据结构，它是限定仅在表的一端进行插入和删除操作的线性表。
栈的一端被称为栈顶（Top），另一端被称为栈底（Bottom）。
在栈中，新元素总是被添加到栈顶，而移除操作总是从栈顶开始。
栈类通常包含以下方法：1. push(E e)：向栈中添加元素e；2. pop()：从栈中移除栈顶元素；3. peek()：查看栈顶元素，但不移除；4. isEmpty()：判断栈是否为空；5. size()：获取栈中元素的数量。
四、实验步骤1. 创建一个名为Stack的类，实现栈的基本功能；2. 在Stack类中定义私有成员变量，用于存储栈的元素；3. 实现push、pop、peek、isEmpty和size方法；4. 编写测试程序，验证Stack类的功能。
以下是Stack类的实现代码：```javapublic class Stack<E> {private E[] elements;private int size;private static final int DEFAULT_CAPACITY = 10;public Stack() {elements = (E[]) new Object[DEFAULT_CAPACITY];size = 0;}public void push(E e) {if (size == elements.length) {elements = Arrays.copyOf(elements, 2 size + 1); }elements[size++] = e;}public E pop() {if (isEmpty()) {throw new IllegalStateException("Stack is empty"); }E e = elements[--size];elements[size] = null;return e;}public E peek() {if (isEmpty()) {throw new IllegalStateException("Stack is empty"); }return elements[size - 1];}public boolean isEmpty() {return size == 0;}public int size() {return size;}}```5. 编写测试程序，验证Stack类的功能：```javapublic class StackTest {public static void main(String[] args) {Stack<Integer> stack = new Stack<>();stack.push(1);stack.push(2);stack.push(3);System.out.println("栈顶元素：" + stack.peek()); // 输出：3System.out.println("栈的大小：" + stack.size()); // 输出：3System.out.println("栈是否为空：" + stack.isEmpty()); // 输出：falsewhile (!stack.isEmpty()) {System.out.println("出栈元素：" + stack.pop()); // 输出：3、2、1}}}```五、实验结论通过本次实验，我们成功实现了栈类的基本功能，包括push、pop、peek、isEmpty和size方法。
栈列实验报告
一、实验目的1. 理解栈的基本概念和操作。
2. 掌握栈的创建、入栈、出栈、判断栈空和栈满等基本操作。
3. 通过实验加深对栈在实际问题中的应用理解。
二、实验仪器1. 计算机一台2. 编程语言：C/C++或Python3. 输入设备：键盘、鼠标4. 输出设备：显示器、打印机三、实验步骤1. 创建栈（1）定义栈的数据结构，包括栈的最大容量、栈顶指针、栈底指针和栈元素数组。
（2）初始化栈，设置栈顶指针为-1，表示栈为空。
2. 入栈操作（1）判断栈是否已满，如果已满，则返回错误信息；如果未满，则将元素插入到栈顶指针指向的位置。
（2）将栈顶指针向上移动一位，表示栈顶元素已增加。
3. 出栈操作（1）判断栈是否为空，如果为空，则返回错误信息；如果栈不为空，则取出栈顶元素。
（2）将栈顶指针向下移动一位，表示栈顶元素已减少。
4. 判断栈空（1）判断栈顶指针是否为-1，如果是，则表示栈为空；如果不是，则表示栈不为空。
5. 判断栈满（1）判断栈顶指针是否等于栈的最大容量减1，如果是，则表示栈已满；如果不是，则表示栈未满。
6. 实验验证（1）创建一个栈，并初始化。
（2）进行一系列的入栈和出栈操作，观察栈的变化。
（3）验证栈空和栈满的判断是否正确。
四、实验结论1. 通过实验，我们成功地实现了栈的创建、入栈、出栈、判断栈空和栈满等基本操作。
2. 实验结果表明，栈是一种后进先出（LIFO）的数据结构，在实际问题中具有广泛的应用。
3. 栈在实际应用中可以解决许多问题，如括号匹配、表达式求值、递归算法等。
五、反思体会1. 在实验过程中，我们深入理解了栈的基本概念和操作，为后续学习数据结构打下了坚实的基础。
2. 通过编写程序实现栈操作，我们提高了编程能力，学会了如何将理论知识应用于实际编程。
3. 在实验过程中，我们遇到了一些问题，如栈满时的错误处理、栈空时的错误处理等。
通过查阅资料和讨论，我们找到了解决方案，提高了自己的问题解决能力。
栈的实验报告分析
一、实验目的1. 理解栈的基本概念和操作。
2. 掌握栈的顺序存储和链式存储实现方式。
3. 熟悉栈在实际问题中的应用。
二、实验内容1. 栈的顺序存储实现2. 栈的链式存储实现3. 栈的应用三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019四、实验步骤1. 栈的顺序存储实现（1）定义栈的数据结构```cpp#define MAXSIZE 100typedef struct {int data[MAXSIZE];int top;} SeqStack;```（2）初始化栈```cppvoid InitStack(SeqStack &S) {S.top = -1;}```（3）判断栈是否为空```cppbool StackEmpty(SeqStack S) {return S.top == -1;}```（4）判断栈是否已满```cppbool StackFull(SeqStack S) {return S.top == MAXSIZE - 1; }```（5）入栈操作```cppbool Push(SeqStack &S, int e) { if (StackFull(S))return false;S.data[++S.top] = e;return true;}```（6）出栈操作```cppbool Pop(SeqStack &S, int &e) { if (StackEmpty(S))return false;e = S.data[S.top--];return true;}```（7）获取栈顶元素```cppbool GetTop(SeqStack S, int &e) { if (StackEmpty(S))return false;e = S.data[S.top];return true;}```2. 栈的链式存储实现（1）定义栈的节点结构```cpptypedef struct StackNode {int data;struct StackNode next;} StackNode, LinkStack;```（2）初始化栈```cppvoid InitStack(LinkStack &S) {S = (LinkStack)malloc(sizeof(StackNode)); if (S == NULL)exit(1);S->next = NULL;}```（3）判断栈是否为空```cppbool StackEmpty(LinkStack S) {return S->next == NULL;}```（4）入栈操作```cppbool Push(LinkStack &S, int e) {StackNode p = (StackNode )malloc(sizeof(StackNode)); if (p == NULL)return false;p->data = e;p->next = S->next;S->next = p;return true;}```（5）出栈操作```cppbool Pop(LinkStack &S, int &e) {if (StackEmpty(S))return false;StackNode p = S->next;e = p->data;S->next = p->next;free(p);return true;}```（6）获取栈顶元素```cppbool GetTop(LinkStack S, int &e) {if (StackEmpty(S))return false;e = S->next->data;return true;}```3. 栈的应用以计算器为例，实现栈在表达式求值中的应用。
栈的实验报告心得(3篇)
第1篇一、实验背景栈（Stack）是一种先进后出（First In Last Out，FILO）的数据结构，它是计算机科学中常用的数据存储方式之一。
在栈中，元素的插入和删除操作只能在栈顶进行。
本实验旨在通过编程实现栈的基本操作，加深对栈的理解和应用。
二、实验目的1. 理解栈的基本概念和特点。
2. 掌握栈的基本操作，如入栈、出栈、判断栈空、判断栈满等。
3. 熟悉栈在实际问题中的应用，提高编程能力。
三、实验内容1. 栈的定义与实现2. 栈的基本操作a. 入栈（Push）b. 出栈（Pop）c. 判断栈空（IsEmpty）d. 判断栈满（IsFull）e. 获取栈顶元素（Peek）3. 栈的应用实例四、实验过程1. 栈的定义与实现首先，我们需要定义一个栈的数据结构。
在C语言中，可以使用结构体（struct）来实现栈：```cdefine MAX_SIZE 100 // 定义栈的最大容量typedef struct {int data[MAX_SIZE]; // 存储栈元素的数组int top; // 栈顶指针} Stack;```2. 栈的基本操作（1）入栈（Push）入栈操作将一个元素添加到栈顶。
在执行入栈操作之前，需要判断栈是否已满。
如果栈未满，则将元素添加到栈顶；如果栈已满，则返回错误信息。
```cint Push(Stack s, int value) {if (s->top == MAX_SIZE - 1) {return -1; // 栈满}s->data[++s->top] = value; // 将元素添加到栈顶return 0; // 成功入栈}```（2）出栈（Pop）出栈操作将栈顶元素移除。
在执行出栈操作之前，需要判断栈是否为空。
如果栈不为空，则将栈顶元素移除；如果栈为空，则返回错误信息。
```cint Pop(Stack s, int value) {if (s->top == -1) {return -1; // 栈空}value = s->data[s->top--]; // 移除栈顶元素return 0; // 成功出栈}```（3）判断栈空（IsEmpty）判断栈空操作用于判断栈是否为空。
数据结构实验报告栈及其应用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后缀表达式求值栈可以用来实现后缀表达式的求值过程，通过入栈和出栈操作计算后缀表达式的值。
五、总结本文详细讨论了栈的概念、特性、实现方式和应用。
通过了解栈的基本操作，我们可以更好地理解栈的原理和使用。
栈在计算机科学领域具有广泛的应用，对于实现递归算法、括号匹配和后缀表达式求值等问题都有重要作用。
对于进一步的学习和实践，我们需要深入理解栈的原理和实现方式，并能熟练运用栈解决问题。
希望本文能为读者对栈及其应用有一个清晰的认识。
关于栈的实验报告
一、实验目的1. 理解栈的定义、特点、逻辑结构。
2. 掌握顺序栈和链栈的实现方法。
3. 熟悉栈的基本操作，如入栈、出栈、判断栈空等。
4. 掌握栈在解决实际问题中的应用。
二、实验内容1. 实现顺序栈和链栈的基本操作。
2. 利用栈实现一个简单的函数调用栈。
3. 实现一个函数，判断给定的字符串是否为回文。
4. 实现一个函数，将一个整数序列的最大值用递归算法求解。
三、实验过程1. 实现顺序栈和链栈的基本操作（1）顺序栈顺序栈使用数组实现，其操作包括入栈（push）、出栈（pop）、判断栈空（isEmpty）、获取栈顶元素（getTop）等。
（2）链栈链栈使用链表实现，其操作包括入栈（push）、出栈（pop）、判断栈空（isEmpty）、获取栈顶元素（getTop）等。
2. 实现一个简单的函数调用栈使用链栈实现函数调用栈，可以模拟函数的嵌套调用过程。
每当调用一个函数时，就将该函数的参数和局部变量压入栈中；当函数返回时，从栈中弹出参数和局部变量。
3. 实现一个函数，判断给定的字符串是否为回文使用顺序栈或链栈实现，将字符串中的字符依次入栈，然后逐个出栈，判断出栈的字符是否与原字符串相同。
如果相同，则字符串为回文；否则，不是回文。
4. 实现一个函数，将一个整数序列的最大值用递归算法求解使用递归算法，每次递归调用将序列中的最大值与下一个元素比较，将较大的值继续向上传递。
最后，递归函数返回序列中的最大值。
四、实验结果与分析1. 顺序栈和链栈的基本操作实现成功，可以满足实验要求。
2. 函数调用栈实现成功，可以模拟函数的嵌套调用过程。
3. 判断字符串是否为回文的函数实现成功，可以正确判断字符串是否为回文。
4. 求解整数序列最大值的递归算法实现成功，可以正确求解序列中的最大值。
五、实验心得通过本次实验，我对栈数据结构有了更深入的理解。
以下是我对实验的一些心得体会：1. 栈是一种后进先出（LIFO）的数据结构，其特点在于只能在栈顶进行插入和删除操作。
(完整版)栈的操作(实验报告)
实验三栈和队列3.1实验目的：（1）熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现；（2）熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。
3.2实验要求：（1）复习课本中有关栈和队列的知识；（2）用C语言完成算法和程序设计并上机调试通过；（3）撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。
3.3基础实验[实验1] 栈的顺序表示和实现实验内容与要求:编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化顺序栈（2）插入元素（3）删除栈顶元素（4）取栈顶元素（5）遍历顺序栈（6）置空顺序栈分析:栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。
对于顺序栈，入栈时，首先判断栈是否为满，栈满的条件为：p->top= =MAXNUM-1，栈满时，不能入栈; 否则出现空间溢出，引起错误，这种现象称为上溢。
出栈和读栈顶元素操作，先判栈是否为空，为空时不能操作，否则产生错误。
通常栈空作为一种控制转移的条件。
注意：（1）顺序栈中元素用向量存放（2）栈底位置是固定不变的，可设置在向量两端的任意一个端点（3）栈顶位置是随着进栈和退栈操作而变化的，用一个整型量top（通常称top为栈顶指针）来指示当前栈顶位置参考程序:#include<stdio.h>#include<stdlib.h>#define MAXNUM 20#define ElemType int/*定义顺序栈的存储结构*/typedef struct{ ElemType stack[MAXNUM];int top;}SqStack;/*初始化顺序栈*/void InitStack(SqStack *p){ if(!p)printf("Eorror");p->top=-1;}/*入栈*/void Push(SqStack *p,ElemType x){ if(p->top<MAXNUM-1){ p->top=p->top+1;p->stack[p->top]=x;}elseprintf("Overflow!\n");}/*出栈*/ElemType Pop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];printf("以前的栈顶数据元素%d已经被删除！\n",p->stack[p->top]);p->top=p->top-1;return(x);}else{ printf("Underflow!\n");return(0);}}/*获取栈顶元素*/ElemType GetTop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];return(x);}else{ printf("Underflow!\n");return(0);}}/*遍历顺序栈*/void OutStack(SqStack *p){ int i;printf("\n");if(p->top<0)printf("这是一个空栈！");printf("\n");for(i=p->top;i>=0;i--)printf("第%d个数据元素是：%6d\n",i,p->stack[i]); }/*置空顺序栈*/void setEmpty(SqStack *p){p->top= -1;}/*主函数*/main(){ SqStack *q;int y,cord;ElemType a;do{printf("\n");printf("第一次使用必须初始化！\n");printf("\n");printf("\n 主菜单\n");printf("\n 1 初始化顺序栈\n");printf("\n 2 插入一个元素\n");printf("\n 3 删除栈顶元素\n");printf("\n 4 取栈顶元素\n");printf("\n 5 置空顺序栈\n");printf("\n 6 结束程序运行\n");printf("\n\n");printf("请输入您的选择( 1, 2, 3, 4, 5,6)");scanf("%d",&cord);printf("\n");switch(cord){ q=(SqStack*)malloc(sizeof(SqStack));InitStack(q);OutStack(q);}break;case 2:{ printf("请输入要插入的数据元素：a=");scanf("%d",&a);Push(q,a);OutStack(q);}break;case 3:{ Pop(q);OutStack(q);}break;case 4:{ y=GetTop(q);printf("\n栈顶元素为：%d\n",y);OutStack(q);}break;case 5:{ setEmpty(q);printf("\n顺序栈被置空！\n");OutStack(q);}break;exit(0);}}while (cord<=6);}[实验2] 栈的链式表示和实现实验内容与要求:编写一个程序实现链栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化链栈（2）链栈置空（3）入栈（4）出栈（5）取栈顶元素（6）遍历链栈分析:链栈是没有附加头结点的运算受限的单链表。
栈的应用实验报告
栈的应用实验报告栈的应用实验报告引言：栈是一种常见的数据结构，它具有后进先出（Last In First Out，LIFO）的特点。
在计算机科学中，栈被广泛应用于各种领域，如编译器、操作系统、图形处理等。
本实验旨在通过实际应用场景，探索栈的应用。
一、栈的基本概念和操作栈是一种线性数据结构，它由一系列元素组成，每个元素都有一个前驱元素和一个后继元素。
栈的基本操作包括入栈（Push）和出栈（Pop）。
入栈将元素添加到栈的顶部，而出栈则将栈顶元素移除。
此外，栈还具有查看栈顶元素（Top）和判断栈是否为空（IsEmpty）的操作。
二、栈在表达式求值中的应用栈在表达式求值中发挥着重要作用。
例如，当我们需要计算一个数学表达式时，可以通过将表达式转换为后缀表达式，并利用栈来进行求值。
栈中存储操作数，当遇到运算符时，从栈中弹出相应数量的操作数进行计算，再将结果入栈。
通过这种方式，我们可以实现高效的表达式求值。
三、栈在函数调用中的应用栈在函数调用中也扮演着重要角色。
当我们调用一个函数时，计算机会将函数的返回地址、参数和局部变量等信息存储在栈中。
这样，当函数执行完毕后，可以从栈中恢复之前的上下文，继续执行调用函数的代码。
栈的这种特性使得递归函数的实现成为可能，同时也为程序的模块化提供了便利。
四、栈在迷宫求解中的应用栈在迷宫求解中也能发挥重要作用。
当我们需要找到从起点到终点的路径时，可以利用栈来存储当前路径上的位置。
从起点开始，我们按照某种策略选择下一个位置，并将其入栈。
如果当前位置无法继续前进，则将其出栈，并选择下一个位置。
通过不断重复这个过程，直到找到终点或者栈为空，我们就能得到迷宫的解。
五、栈在撤销和恢复操作中的应用栈在撤销和恢复操作中也能发挥重要作用。
当我们在编辑文档或者绘图时，经常需要进行撤销和恢复操作。
栈可以用来记录每次操作的状态，当用户选择撤销时，从栈中弹出最近的操作，并将文档或图形恢复到之前的状态。
通过这种方式，我们可以提供良好的用户体验，同时也方便用户进行操作的回溯。
关于栈的实验报告
关于栈的实验报告引言栈（Stack）是一种常用的数据结构，它基于后进先出（Last In First Out，LIFO）的原则，元素的插入和删除操作只能在栈顶进行。
栈具有快速插入和删除元素的特点，因此在很多应用中广泛使用。
本实验旨在通过编写一个栈的实现，探究栈的基本操作以及应用，并对栈的性能进行评估。
一、栈的实现1. 栈的定义使用数组来实现一个基本的栈结构，可以定义一个栈类`Stack`，其中包含以下属性和方法：- 属性：- `max_size`：栈的最大容量- `top`：栈顶指针- `data`：存储栈元素的数组- 方法：- `__init__(self, size)`：构造函数，初始化栈对象，参数为栈的最大容量- `is_empty(self)`：判断栈是否为空- `is_full(self)`：判断栈是否已满- `push(self, item)`：将元素压入栈顶- `pop(self)`：从栈顶弹出一个元素- `peek(self)`：返回栈顶元素- `size(self)`：返回栈的当前大小- `clear(self)`：清空栈中所有元素2. 栈的实现pythonclass Stack:def __init__(self, size):self.max_size = sizeself.top = -1self.data = [None] * sizedef is_empty(self):return self.top == -1def is_full(self):return self.top == self.max_size - 1 def push(self, item):if self.is_full():print("Stack is full.")returnself.top += 1self.data[self.top] = itemdef pop(self):if self.is_empty():print("Stack is empty.")return Noneitem = self.data[self.top]self.top -= 1return itemdef peek(self):if self.is_empty():print("Stack is empty.")return Nonereturn self.data[self.top]def size(self):return self.top + 1def clear(self):self.top = -1上述代码实现了一个基本的栈，其中使用一个列表`data` 来存储栈的元素，`top` 表示栈顶指针，初始值为-1。
栈的实验报告
栈的实验报告栈的实验报告引言：栈是一种常用的数据结构，它具有先进后出（Last In First Out, LIFO）的特点。
在本次实验中，我们将通过编写代码实现栈的基本操作，并进行相应的测试和分析。
一、栈的定义和基本操作栈是一种线性数据结构，它可以通过数组或链表来实现。
栈的基本操作包括入栈（push）、出栈（pop）、获取栈顶元素（top）以及判断栈是否为空（isEmpty）等。
二、栈的实现在本次实验中，我们选择使用数组来实现栈。
首先，我们需要定义一个栈的结构体，其中包含一个整型数组和一个指向栈顶的指针。
具体的代码如下所示：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;```接下来，我们可以实现栈的基本操作。
具体的代码如下所示：```c// 初始化栈void initStack(Stack *s) {s->top = -1;}// 判断栈是否为空int isEmpty(Stack *s) {return s->top == -1;}// 判断栈是否已满int isFull(Stack *s) {return s->top == MAX_SIZE - 1; }// 入栈void push(Stack *s, int value) {if (isFull(s)) {printf("Stack is full.\n");return;}s->data[++s->top] = value;}// 出栈int pop(Stack *s) {if (isEmpty(s)) {printf("Stack is empty.\n");return -1;}return s->data[s->top--];}// 获取栈顶元素int top(Stack *s) {if (isEmpty(s)) {printf("Stack is empty.\n");return -1;}return s->data[s->top];}```三、栈的测试与分析为了验证我们实现的栈是否正确，我们可以编写一些测试代码来进行验证。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三栈和队列3.1实验目的：（1）熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现；（2）熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。
3.2实验要求：（1）复习课本中有关栈和队列的知识；（2）用C语言完成算法和程序设计并上机调试通过；（3）撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。
3.3基础实验[实验1] 栈的顺序表示和实现实验容与要求:编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化顺序栈（2）插入元素（3）删除栈顶元素（4）取栈顶元素（5）遍历顺序栈（6）置空顺序栈分析:栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。
对于顺序栈，入栈时，首先判断栈是否为满，栈满的条件为：p->top= =MAXNUM-1，栈满时，不能入栈; 否则出现空间溢出，引起错误，这种现象称为上溢。
出栈和读栈顶元素操作，先判栈是否为空，为空时不能操作，否则产生错误。
通常栈空作为一种控制转移的条件。
注意：（1）顺序栈中元素用向量存放（2）栈底位置是固定不变的，可设置在向量两端的任意一个端点（3）栈顶位置是随着进栈和退栈操作而变化的，用一个整型量top（通常称top为栈顶指针）来指示当前栈顶位置参考程序:#include<stdio.h>#include<stdlib.h>#define MAXNUM 20#define ElemType int/*定义顺序栈的存储结构*/typedef struct{ ElemType stack[MAXNUM];int top;}SqStack;/*初始化顺序栈*/void InitStack(SqStack *p){ if(!p)printf("Eorror");p->top=-1;}/*入栈*/void Push(SqStack *p,ElemType x){ if(p->top<MAXNUM-1){ p->top=p->top+1;p->stack[p->top]=x;}elseprintf("Overflow!\n");}/*出栈*/ElemType Pop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];printf("以前的栈顶数据元素%d已经被删除！\n",p->stack[p->top]);p->top=p->top-1;return(x);}else{ printf("Underflow!\n");return(0);}}/*获取栈顶元素*/ElemType GetTop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];return(x);}else{ printf("Underflow!\n");return(0);}}/*遍历顺序栈*/void OutStack(SqStack *p){ int i;printf("\n");if(p->top<0)printf("这是一个空栈！");printf("\n");for(i=p->top;i>=0;i--)printf("第%d个数据元素是：%6d\n",i,p->stack[i]); }/*置空顺序栈*/void setEmpty(SqStack *p){p->top= -1;}/*主函数*/main(){ SqStack *q;int y,cord;ElemType a;do{printf("\n");printf("第一次使用必须初始化！\n");printf("\n");printf("\n 主菜单 \n");printf("\n 1 初始化顺序栈 \n");printf("\n 2 插入一个元素 \n");printf("\n 3 删除栈顶元素 \n");printf("\n 4 取栈顶元素 \n");printf("\n 5 置空顺序栈 \n");printf("\n 6 结束程序运行 \n");printf("\n--------------------------------\n");printf("请输入您的选择( 1, 2, 3, 4, 5,6)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:{ q=(SqStack*)malloc(sizeof(SqStack));InitStack(q);OutStack(q);}break;case 2:{ printf("请输入要插入的数据元素：a=");scanf("%d",&a);Push(q,a);OutStack(q);}break;case 3:{ Pop(q);OutStack(q);}break;case 4:{ y=GetTop(q);printf("\n栈顶元素为：%d\n",y);OutStack(q);}break;case 5:{ setEmpty(q);printf("\n顺序栈被置空！\n");OutStack(q);}break;case 6:exit(0);}}while (cord<=6);}[实验2] 栈的链式表示和实现实验容与要求:编写一个程序实现链栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化链栈（2）链栈置空（3）入栈（4）出栈（5）取栈顶元素（6）遍历链栈分析:链栈是没有附加头结点的运算受限的单链表。
栈顶指针就是链表的头指针。
注意：（1）LinkStack结构类型的定义可以方便地在函数体中修改top指针本身（2）若要记录栈中元素个数，可将元素个数属性放在LinkStack类型中定义。
（3）链栈中的结点是动态分配的，所以可以不考虑上溢。
参考程序:#include "stdio.h"#include "malloc.h"#include "stdlib.h"typedef int Elemtype;typedef struct stacknode {Elemtype data;stacknode * next;}StackNode;typedef struct {stacknode * top; //栈顶指针}LinkStack;/*初始化链栈*/void InitStack(LinkStack * s){ s->top=NULL;printf("\n已经初始化链栈！\n");}/*链栈置空*/void setEmpty(LinkStack * s){ s->top=NULL;printf("\n链栈被置空！\n");}/*入栈*/void pushLstack(LinkStack * s, Elemtype x){ StackNode * p;p=(StackNode *)malloc(sizeof(StackNode)); //建立一个节点。
p->data=x;p->next=s->top; //由于是在栈顶pushLstack，所以要指向栈顶。
s->top=p; //插入}/*出栈*/Elemtype popLstack(LinkStack * s){ Elemtype x;StackNode * p;p=s->top; //指向栈顶if (s->top ==0){ printf("\n栈空，不能出栈！\n");exit(-1);}x=p->data;s->top=p->next; //当前的栈顶指向原栈的nextfree(p); //释放return x;}/*取栈顶元素*/Elemtype StackTop(LinkStack *s){ if (s->top ==0){ printf("\n链栈空\n");exit(-1);}return s->top->data;}/*遍历链栈*/void Disp(LinkStack * s){ printf("\n链栈中的数据为：\n");printf("=======================================\n");StackNode * p;p=s->top;while (p!=NULL){ printf("%d\n",p->data);p=p->next;}printf("=======================================\n");}void main(){ printf("================= 链栈操作=================\n\n");int i,m,n,a;LinkStack * s;s=(LinkStack *)malloc(sizeof(LinkStack));int cord;do{ printf("\n");printf("第一次使用必须初始化！\n");printf("\n");printf("\n 主菜单 \n");printf("\n 1 初始化链栈 \n");printf("\n 2 入栈 \n");printf("\n 3 出栈 \n");printf("\n 4 取栈顶元素 \n");printf("\n 5 置空链栈 \n");printf("\n 6 结束程序运行 \n");printf("\n--------------------------------\n");printf("请输入您的选择( 1, 2, 3, 4, 5,6)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:{ InitStack(s);Disp(s);}break;case 2:{printf("输入将要压入链栈的数据的个数：n=");scanf("%d",&n);printf("依次将%d个数据压入链栈：\n",n);for(i=1;i<=n;i++){scanf("%d",&a);pushLstack(s,a);}Disp(s);}break;case 3:{ printf("\n出栈操作开始!\n");printf("输入将要出栈的数据个数：m=");scanf("%d",&m);for(i=1;i<=m;i++){printf("\n第%d次出栈的数据是：%d",i,popLstack(s));}Disp(s);}break;case 4:{ printf("\n\n链栈的栈顶元素为：%d\n",StackTop(s));printf("\n");}break;case 5:{ setEmpty(s);Disp(s);}break;case 6:exit(0);}}while (cord<=6);}[实验3] 队列的顺序表示和实现实验容与要求编写一个程序实现顺序队列的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化队列（2）建立顺序队列（3）入队（4）出队（5）判断队列是否为空（6）取队头元素（7）遍历队列分析:队列的顺序存储结构称为顺序队列，顺序队列实际上是运算受限的顺序表。