顺序栈基本操作实验报告材料
栈的实验报告结论(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）测试程序：验证了栈在程序设计中的应用。
顺序栈实验报告
顺序栈实验报告1. 实验目的本实验旨在通过实现顺序栈的基本操作，加深对栈的理解，并学习如何使用顺序栈解决实际问题。
2. 实验内容本实验包含以下内容：1.实现栈的初始化操作，并判断栈是否为空；2.实现入栈操作，将元素插入栈顶；3.实现出栈操作，将栈顶元素删除，并返回删除的元素；4.实现获取栈顶元素的操作，不改变栈的结构；5.实现获取栈的长度操作。
3. 实验步骤3.1 栈的初始化首先，我们需要定义一个顺序栈的结构体，其中包括栈的容量、栈顶指针和存放元素的数组。
栈的容量可以根据实际需要进行调整，栈顶指针初始值为-1。
#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} SqStack;然后，我们可以编写初始化栈的函数：void InitStack(SqStack *s) {s->top = -1;}3.2 判断栈是否为空我们可以通过栈顶指针的值是否等于-1来判断栈是否为空，编写如下函数：int IsEmpty(SqStack *s) {if (s->top == -1) {return1;} else {return0;}}3.3 入栈操作入栈操作即将元素插入栈顶。
在插入元素前，我们需要判断栈是否已满。
若栈未满，则将元素插入栈顶，并更新栈顶指针的值。
编写如下函数：int Push(SqStack *s, int x) {if (s->top == MAX_SIZE - 1) {return0; // 栈满，插入失败} else {s->top++;s->data[s->top] = x;return1; // 插入成功}}3.4 出栈操作出栈操作即将栈顶元素删除，并返回删除的元素。
在删除元素前，我们需要判断栈是否为空。
若栈不为空，则将栈顶元素删除，并更新栈顶指针的值。
编写如下函数：int Pop(SqStack *s, int *x) {if (IsEmpty(s)) {return0; // 栈空，删除失败} else {*x = s->data[s->top];s->top--;return1; // 删除成功}}3.5 获取栈顶元素获取栈顶元素不改变栈的结构，只需要返回栈顶指针对应的元素即可。
【最新推荐】顺序栈实验报告word版本 (13页)
本文部分内容来自网络整理，本司不为其真实性负责，如有异议或侵权请及时联系，本司将立即删除！== 本文为word格式，下载后可方便编辑和修改！ ==顺序栈实验报告篇一：数据结构顺序栈实验报告一、设计人员相关信息1. 设计者姓名、学号和班号：12地信李晓婧 1201X2429832. 设计日期：201X.3. 上机环境：VC++6.0二、程序设计相关信息1. 实验题目：编写一个程序，实现顺序栈（假设栈中元素类型为char）的各种基本运算，并在此基础上设计一个程序，完成如下功能：（1）初始化栈（2）判断栈是否为空（3）依次进栈元素a,b,c,d,e（4）判断栈是否为空（5）输出栈长度（6）输出从栈顶到栈底元素（7）输出出栈序列（8）判断栈是否为空（9）释放栈2. 实验项目组成：栈的初始化、销毁、判断是否为空、进栈、出栈、取栈顶元素。
3. 实验项目的程序结构（程序中的函数调用关系图）：4. 实验项目包含的各个文件中的函数的功能描述：（1）初始化栈InitStack：建立一个新的空栈，实际上将栈顶指针指向-1即可。
（2）销毁栈DestroyStack：释放栈占用的存储空间（3）判断栈是否为空StackEmpty：栈为空的条件是s->op==-1。
（4）进栈Push：在栈不满的条件下，先将栈顶指针增1，然后在栈顶指针指向位置插入元素e。
（5）出栈Pop：在栈不为空的条件下，先将栈顶元素赋给e，然后将栈顶指针减1.（6）取栈顶元素GetTop：在栈不为空的条件下，将栈顶元素赋给e。
5. 算法描述或流程图：#include "stdio.h"#include "malloc.h"#include<stdlib.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; /*栈顶指针*/}SqStack;//定义顺序栈类型void InitStack(SqStack*&s)/*初始化*/{s=(SqStack*)malloc(sizeof(SqStack));s->top=-1;//栈顶指针置为-1}void DestroyStack(SqStack *&s)/*销毁*/{free(s);}int StackEmpty(SqStack*s)/*判断是否为空*/{return(s->top==-1);}int push(SqStack *&s,ElemType a[],int n){int i; if(s->top==MaxSize-1)//栈满的情况，即栈上溢出 return 0; for(i=0;i<n;i++){ s->top++; //栈顶指针增1s->data[s->top]=a[i];//元素e放在栈顶指针处}int Pop(SqStack*&s,ElemType &e)/*出栈一个元素*/ {if(s->top==-1)//栈为空的情况，即栈下溢出 return 0;e=s->data[s->top]; //取栈顶元素s->top--; //栈顶指针减1return 1;}} return 1;int GetTop(SqStack *s,ElemType &e)/*取栈顶元素*/ {if(s->top==-1) //栈为空的情况，即栈下溢出 return 0;e=s->data[s->top];//取栈顶元素return 1;}int StackLength(SqStack *s)/*求栈长度*/{return(s->top+1);}void DispStack(SqStack *s){}void main(){int i,j;ElemType str[5]={'a','b';,'c','d','e'}; //定义字符数组 SqStack *st;//定义栈InitStack(st);/*初始化*/i=StackEmpty(st);//判断栈是否为空if(i==0) int i; for(i=s->top;i>=0;i--) printf("%c",s->data[i]); printf("\n");printf("顺序栈非空\n"); else printf("顺序栈为空\n");push(st,str,5); //进栈j=StackEmpty(st);if(j==0)printf("顺序栈非空\n"); else printf("顺序栈为空\n");printf("栈长度为：%d\n",StackLength(st)); //输出栈长度。
栈的建立实验报告
一、实验目的本次实验旨在通过编程实现栈的顺序存储结构和链式存储结构，并熟练掌握栈的基本操作，包括栈的建立、入栈、出栈、取栈顶元素、判栈空等。
通过实验，加深对栈这一数据结构的理解，提高数据结构在实际问题中的应用能力。
二、实验内容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．顺序栈的基本操作二、实验目的及要求熟悉栈的基本操作在顺序栈的实现。
通过具体应用实例在复习高级编程语言使用方法的基础上初步了解数据结构的应用。
三、设计分析与算法描述顺序栈的存储结构：typedef struct{int elem[Stack_Size];int top;}SeqStack;void InitStack(SeqStack *S)//构造一个空栈(初始化)int Push(SeqStack *S,int x)//进栈int Pop(SeqStack *S,int *x)//出栈int IsEmpty(SeqStack *S)//判栈是否空int IsFull(SeqStack *S)//判栈是否满int GetTop(SeqStack *S,int *x)//读栈顶四、附件：带注释的源程序#include"iostream.h"#define Stack_Size 50#define false 0#define true 1typedef struct{int elem[Stack_Size];int top;}SeqStack;void InitStack(SeqStack *S)//构造一个空栈(初始化) {S->top=-1;}int Push(SeqStack *S,int x)//进栈{if(S->top==Stack_Size-1)//栈已满return (false);S->top++;S->elem[S->top]=x;return (true);}int Pop(SeqStack *S,int *x)//出栈{if(S->top==-1)//栈已空return (false);else{*x=S->elem[S->top];S->top--;return (true);}}int IsEmpty(SeqStack *S)//判栈是否空{if(S->top==-1)return (true);elsereturn (false);}int IsFull(SeqStack *S)//判栈是否满{if(S->top==Stack_Size-1)return (true);elsereturn (false);}int GetTop(SeqStack *S,int *x)//读栈顶{if(S->top==-1)return (false);else{*x=S->elem[S->top];return (true);}}int main(){int i,temp;SeqStack st;InitStack(&st);for(i=0;i<10;i++)Push(&st,i);while(IsEmpty(&st)){Pop(&st,&temp);cout<<temp<<endl;}return 0;}。
数据结构实验报告顺序栈
数据结构实验报告顺序栈一、实验目的本次实验的主要目的是深入理解和掌握顺序栈这种数据结构的基本概念、操作原理以及在实际编程中的应用。
通过实际编写代码和进行实验操作，提高对数据结构的理解和编程能力，培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程环境是Visual Studio 2019，编程语言为C+＋。
三、顺序栈的概念顺序栈是一种线性数据结构，它是基于数组实现的。
顺序栈遵循“后进先出”（Last In First Out，LIFO）的原则，即最后入栈的元素最先出栈。
顺序栈需要预先分配一块连续的存储空间来存储栈中的元素。
在操作过程中，通过一个栈顶指针来指示当前栈顶的位置。
当进行入栈操作时，如果栈未满，则将新元素添加到栈顶指针所指的位置，并将栈顶指针向上移动一位；当进行出栈操作时，如果栈非空，则取出栈顶元素，并将栈顶指针向下移动一位。
四、顺序栈的操作（一）初始化操作｀｀｀cpptypedef struct ｛int data;int top;int capacity;｝ SeqStack;void initStack(SeqStack ＆s, int capacity) ｛sdata ＝ new intcapacity;stop ＝－1;scapacity ＝ capacity;｝｀｀｀在初始化函数中，为顺序栈分配指定大小的存储空间，并将栈顶指针初始化为－1，表示栈为空。
（二）入栈操作｀｀｀cppbool push(SeqStack ＆s, int x) ｛if （stop ＝＝ scapacity 1) ｛return false;｝sdata+＋stop ＝ x;return true;｝｀｀｀入栈操作首先检查栈是否已满，如果未满，则将新元素添加到栈顶，并更新栈顶指针。
（三）出栈操作｀｀｀cppbool pop(SeqStack ＆s, int ＆x) ｛if （stop ＝＝－1) ｛return false;｝x ＝ sdatastop;return true;｝｀｀｀出栈操作首先检查栈是否为空，如果非空，则取出栈顶元素，并更新栈顶指针。
顺序栈的存取实验报告
一、实验目的1. 理解顺序栈的定义和基本操作。
2. 掌握顺序栈的存储结构及其实现方法。
3. 能够通过C语言实现顺序栈的入栈和出栈操作。
4. 通过实验验证顺序栈的存取效率。
二、实验原理顺序栈是一种利用数组实现的栈结构，其特点如下：1. 顺序栈使用数组存储数据元素，数组的大小是固定的，栈顶指针top指向栈顶元素。
2. 顺序栈的入栈操作是将新元素添加到栈顶，出栈操作是删除栈顶元素。
3. 栈顶指针top的初始值为-1，表示栈为空。
顺序栈的入栈和出栈操作如下：1. 入栈操作：- 判断栈是否已满，若已满则报错。
- 将新元素添加到栈顶，栈顶指针top加1。
2. 出栈操作：- 判断栈是否为空，若为空则报错。
- 删除栈顶元素，栈顶指针top减1。
三、实验内容1. 定义顺序栈的数据结构。
2. 实现顺序栈的初始化、入栈、出栈和判空操作。
3. 编写主函数，验证顺序栈的存取操作。
四、实验步骤1. 定义顺序栈的数据结构，包括栈的最大容量、栈顶指针和栈顶元素数组。
```c#define MAXSIZE 100typedef struct {int data[MAXSIZE];int top;} SeqStack;```2. 实现顺序栈的初始化、入栈、出栈和判空操作。
```c// 初始化顺序栈void InitStack(SeqStack s) {s->top = -1;}// 判断栈是否为空int IsEmpty(SeqStack s) {return s->top == -1;}// 入栈操作int Push(SeqStack s, int e) {if (s->top == MAXSIZE - 1) {return 0; // 栈已满}s->data[++s->top] = e;return 1;}// 出栈操作int Pop(SeqStack s, int e) {if (s->top == -1) {return 0; // 栈为空}e = s->data[s->top--];return 1;}```3. 编写主函数，验证顺序栈的存取操作。
栈的基本操作实验报告
一、实验目的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;}```五、实验心得通过本次实验，我对栈的基本操作有了更深入的理解。
实验报告04-顺序栈的基本操作
实验报告04-顺序栈的基本操作实验目的及要求：了解和掌握顺序栈的特点；掌握顺序栈基本操作的实现；要求完成顺序栈的初始化、入栈、出栈、取栈顶元素、显示操作的实现。
实验设备环境及要求：PC机一台，内存要求128M以上，VC++6.0集成开发环境。
实验内容与步骤：1、在VC++6.0环境中新建一个工程和C++文件；2、实现顺序栈初始化、入栈、出栈、取栈顶元素算法，代码如下：#include#include#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef char SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S){S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) return 0;S.top = S.base;S.stacksize = STACK_INIT_SIZE;return 1;}int GetT op(SqStack S,SElemType &e){if(S.top == S.base) return 0;e = *(S.top-1);return 1;}int Push(SqStack &S,SElemType e){if(S.top-S.base>= S.stacksize){S.base = (SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SEle mType));if(!S.base) return 0;S.top = S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++ = e;return 1;}int Pop(SqStack &S,SElemType &e){if(S.top == S.base) return 0;e = *--S.top;return 1;}void DispStack(SqStack S) //从栈顶到栈底输出元素{int i;if(S.top==S.base)printf("空栈！");for(i=S.top-S.base; i>0; i--)printf("%c",S.base[i-1]);printf("\n");}void main(){SElemType e;SqStack S;InitStack(S);Push(S,'A');Push(S,'B');Push(S,'C');Push(S,'D');printf("栈S为：");DispStack(S);GetTop(S,e);printf("栈顶元素是：");printf("%c\n",e);Pop(S,e);printf("栈S为：");DispStack(S);}实验指导与数据处理：实验结果：栈S为：DCBA栈顶元素是：D栈S为：CBA分析讨论：本次实验通过对顺序栈基本操作的实现，加深了对顺序栈特点的理解，并且熟悉了VC++6.0集成环境，虽然在调试过程中遇到一些问题，但经分析后达到了预期的结果。
新版顺序栈实验报告-新版-精选.pdf
第 2页
for (i=s->top;i>=0;i--) printf("%c ",s->elem[i]);
printf("\n"); }
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct
extern int StackEmpty(SqStack *s);
extern int Push(SqStack *&s,ElemType e);
extern int Pop(SqStack *&s,ElemType &e);
extern int GetTop(SqStack *s,ElemType &e);
{
ElemType elem[MaxSize];
int top;
/* 栈指针 */
} tSqStack;
extern void InitStack(SqStack *&s);
extern void ClearStack(SqStack *&s);
extern int StackLength(SqStack *s);
return(s->top==-1); } int Push(SqStack *&s,ElemType e) {
if (s->top==MaxSize-1) return 0;
s->top++; s->elem[s->top]=e; return 1; } int Pop(SqStack *&s,ElemType &e) { if (s->top==-1)
实验报告4-顺序栈
实验报告－4
课程名__数据结构实验名称_顺序栈的简单操作实现
实验日期年月日实验报告日期年月日姓名_________学号_____________
一、实验目的
1、掌握顺序存储的线性表的简单操作
2、理解数据结构中不同存储实现下的头文件（list.h）
二、实验内容
编写一个程序实现如栈的入栈、出栈、取栈顶元素和遍历栈操作：
三、实验环境
四、实验步骤
（描述实验步骤及中间的结果或现象。
在实验中做了什么事情，怎么做的，发生的现象和中间结果）
五、实验结果
（相关文件制成压缩文件提交，注明文件名）
六、总结
（说明实验过程中遇到的问题及解决办法；个人的收获；未解决的问题等）。
数据结构实验报告_栈(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。
栈的顺序实验报告
一、实验目的本次实验旨在使学生掌握栈的顺序存储结构，理解栈的基本操作，并能够通过编程实现栈的初始化、入栈、出栈、判空、取栈顶等基本功能。
同时，通过实验加深对数据结构中栈的应用理解，提高编程能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio三、实验内容1. 栈的顺序存储结构- 实现栈的顺序存储结构，包括定义栈的存储空间和栈顶指针。
- 设计栈的初始化、判空、入栈、出栈、取栈顶等基本操作。
2. 栈的基本操作- 编写代码实现栈的初始化函数，初始化栈的空间和栈顶指针。
- 实现判空函数，检查栈是否为空。
- 实现入栈函数，将元素添加到栈顶。
- 实现出栈函数，从栈顶移除元素。
- 实现取栈顶函数，获取栈顶元素但不移除。
3. 栈的应用- 利用栈实现十进制数与二进制数的转换。
- 利用栈实现函数调用栈，模拟函数调用的过程。
四、实验步骤1. 定义栈的结构体```ctypedef struct {int array; // 动态分配的数组，用于存储栈元素 int top; // 栈顶指针int maxSize; // 栈的最大容量} SeqStack;```2. 实现栈的基本操作- 初始化栈```cvoid InitStack(SeqStack s, int maxSize) {s->array = (int )malloc(sizeof(int) maxSize); s->top = -1;s->maxSize = maxSize;}```- 判空```cint IsEmpty(SeqStack s) {return s->top == -1;}```- 入栈```cint Push(SeqStack s, int x) {if (s->top == s->maxSize - 1) { return 0; // 栈满}s->array[++s->top] = x;return 1;}```- 出栈```cint Pop(SeqStack s, int x) {if (IsEmpty(s)) {return 0; // 栈空}x = s->array[s->top--];return 1;}```- 取栈顶```cint GetTop(SeqStack s, int x) {if (IsEmpty(s)) {return 0; // 栈空}x = s->array[s->top];return 1;}```3. 实现十进制数与二进制数的转换- 编写函数实现十进制数转换为二进制数，利用栈存储转换过程中的余数。
数据结构 顺序栈
《数据结构》实验报告二专业：自动化班级：0710学号：姓名：日期：2009. 11.17 程序：顺序栈计算表达式实验二用顺序栈计算表达式一【实验内容与要求】问题描述：利用栈的基本操作实现一个算术表达式的求值的程序。
基本要求：（1）定义栈的顺序存取结构。
（2）分别定义顺序栈的基本操作（初始化栈、判栈空否、入栈、出栈等）。
（3）定义一个函数用来计算表达式结果，并且可以显示表达式的后缀表示。
（4）设计一个测试主函数进行测试。
【测试数据】输入：4+5*2+9+（-5）^2=输出：4+5*2+9+（-5）^2=48.00二、程序设计的基本思想，原理和算法描述：1）：符号说明Functor 算符栈结构体NUM 运算对象栈ch 存放输入的字符fun 算符grade 算符的等级value 临时用来存放数据result 表示最终运算结果2）算法描述：先通过键盘键入中缀表达式，然后将其中的运算对象和算符依次分开，分别存入运算栈和算符栈内，初始化算符栈等级。
按照中缀表达式的方法，计算结果。
三、源程序及注释：typedef struct //定义算符栈结构体{char fun;// 算符int grade//算符的等级}Functor;Functor FUNCTOR[20];float NUM[20]; //定义算符栈和对象栈char ch[100]; //存放输入流的字符串int sub=0;//定义全局变量来一次取字符float Char_To_Num(){//将表示数据的int flag=0, i=-1;float value=0.0;//用来表示字符串转化成数据后的数据while((ch[sub]>=48 && ch[sub]<=57) || ch[sub]=='.'){//48表示0的asc值，57表示9的，用于判断取的字符是否在0到9之间if(ch[sub]=='.')flag=1; //取的字是.号时flag为1else{if(flag==0) value=value*10+ch[sub]-48;//计算整数部分else{value=value+( ch[sub]-48 )*pow(10,i);//计算小数部分i--;//表示计算下一位小数做好准备}}sub++;//自加表示为取下一个字符做好准备}return value;//返回数字}int In_Grade(char c){ //算符在栈内时的级别int g;switch(c){case '^': g=3;break;// 表示^的等级为3case '*': 表示*的等级为3case '/': 表示*的等级为3case '%': g=2;break; 表示%的等级为2case '+':case '-': g=1;break; 表示+- 的等级为1case '(': g=0;break; 表示(等级为0case ')': g=-1;break; 表示(等级为0}return g; 返回所得的算符的等级}int Out_Grade(){ //算符在栈外时的级别int g;switch(ch[sub]){case '^': g=4;break; //表示^的等级为4case '*':case '/': 表示* / % 的等级为2case '%': g=2;break;case '+':case '-': g=1;break; 表示+- 的等级为1case '(': g=4;break; 表示(等级为4case ')': g=-1;break; 表示)等级为-1}return g; 返回算符的栈外等级}void Error(){printf("输入的表达式有误！\n");printf("\n按任意键退出");getch();exit(1);}void Calculate(int i, int j)//计算子程序{if(i>=2){ //判断对象栈中元素个数switch(FUNCTOR[j-1].fun)//{case '^': NUM[i-2]=pow(NUM[i-2],NUM[i-1]); break//具体计算过程表示;+-*/^%case '*': NUM[i-2]=NUM[i-2]*NUM[i-1]; break;case '/': NUM[i-2]=NUM[i-2]/NUM[i-1]; break;case '%': NUM[i-2]=int(NUM[i-2])%int(NUM[i-1]); break;case '+': NUM[i-2]=NUM[i-2]+NUM[i-1]; break;case '-': NUM[i-2]=NUM[i-2]-NUM[i-1]; break;}NUM[i-1]=0;//计算完之后num清零FUNCTOR[j-1].fun=0;//计算完之后算符清零}else Error();//若对象栈若只剩一个数据，则输入的表达式有误}float Char_Transform(){int i=0, j=0, grade, flag=0;while( ch[sub]!='=' || j!=0 ){//用来控制字符是否取完if(ch[sub]=='='){//输入的字符是否取完Calculate(i, j);计算最后两个运算对像i--;j--;}else{if(ch[sub]>=48 && ch[sub]<=57){//判断是否为运算对象NUM[i++]=Char_To_Num();//将离散的字符转换成连续数字if(flag){NUM[i-1]=-NUM[i-1];//如果flag=1，即前面有-，将运算对象取反FUNCTOR[j-1].fun=0;j--;flag=0;}}else{if(ch[sub]=='%' ||(ch[sub]>=40 && ch[sub]<=43) ||ch[sub]=='-' ||ch[sub]=='^' ||ch[sub]=='/'){//判断是否为算符if( FUNCTOR[j-1].fun=='-' &&FUNCTOR[j-2].fun=='(' &&ch[sub]==')'){//判断是否为负数NUM[i-1]=-NUM[i-1];FUNCTOR[j-1].fun=0;FUNCTOR[j-2].fun=0;j=j-2;sub++;}else{if( FUNCTOR[j-1].fun== '(' && ch[sub]== ')' ){//括号内表达式计算完后则将左括号从栈中去除FUNCTOR[j-1].fun=0;//清零j--;sub++;}else{grade=Out_Grade(); //栈外算符的级别if(j==0 || grade>FUNCTOR[j-1].grade){//第一个或级别比栈内算符高的进栈FUNCTOR[j].fun=ch[sub];FUNCTOR[j].grade=In_Grade(ch[sub]);if(j==0 && FUNCTOR[j].fun=='-') flag=1;j++;sub++;}else{Calculate(i, j);如果第一个或级别比栈内算符低，直接将栈内的算符取出计算i--;j--;}}}}else Error();//表达式中有非算术字符，则表达式有误}}}return NUM[i-1];}int main(){float result;printf("****************************************\n");printf("请输入要求解的表达式,并以等号“=”结束:\n");printf("****************************************\n");gets(ch);//输入要计算的表达式result=Char_Transform();//调用函数Char_Transform()将结果送到result printf("%s%.2f\n", ch, result);printf("\n按任意键退出");getch();}四、运行输出结果五、调试和运行程序过程中产生的问题及采取的措施：由于这个程序不是自己写的，没有比较具体的调试过程，所以对整个理解不是那么深。
关于栈的实验报告
一、实验目的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. 通过实际编程实现顺序栈，并验证其功能。
二、实验内容1. 栈的基本概念栈是一种特殊的线性表，它只允许在一端进行插入和删除操作。
栈的插入和删除操作遵循“后进先出”（LIFO）的原则。
2. 顺序栈的定义顺序栈使用数组来存储栈中的元素，数组的大小定义为MaxSize。
栈顶指针top 指向栈顶元素。
3. 顺序栈的基本操作（1）初始化：将栈顶指针top设置为-1，表示栈为空。
（2）进栈：判断栈是否已满，如果未满，则将新元素放入栈顶，并将栈顶指针top加1。
（3）出栈：判断栈是否为空，如果栈不为空，则将栈顶元素弹出，并将栈顶指针top减1。
（4）读栈顶元素：判断栈是否为空，如果栈不为空，则返回栈顶元素。
（5）栈的销毁：释放栈所占用的内存空间。
4. 实验步骤（1）定义栈的最大容量MaxSize；（2）创建顺序栈结构体；（3）实现顺序栈的基本操作函数；（4）编写主函数，测试顺序栈的功能。
1. 定义栈的最大容量MaxSize为100；2. 创建顺序栈结构体，包含数组data和栈顶指针top；3. 实现顺序栈的基本操作函数，包括初始化、进栈、出栈、读栈顶元素和栈的销毁；4. 编写主函数，创建顺序栈，进行进栈、出栈、读栈顶元素等操作，并输出结果。
四、实验结果与分析1. 初始化顺序栈初始化顺序栈后，栈顶指针top为-1，表示栈为空。
2. 进栈操作当向顺序栈中进栈元素时，首先判断栈是否已满。
如果栈未满，则将新元素放入栈顶，并将栈顶指针top加1。
3. 出栈操作当从顺序栈中出栈元素时，首先判断栈是否为空。
如果栈不为空，则将栈顶元素弹出，并将栈顶指针top减1。
4. 读栈顶元素操作当读取栈顶元素时，首先判断栈是否为空。
如果栈不为空，则返回栈顶元素。
5. 栈的销毁当栈不再需要时，释放栈所占用的内存空间。
实验结果表明，顺序栈的基本操作能够正常进行，验证了顺序栈的正确性。
实验一一个顺序栈的基本运算实验
实验一一个顺序栈的基本运算实验一、实验目的：对一个顺序栈的基本运算进行分析与设计，回顾数据结构所学过的知识，掌握一个顺序栈的基本运算实现，为下一步的实验奠定基础。
二、实验要求：要求对一个顺序栈的基本运算作设计性实验，并上机运行，撰写实验报告。
三、实验内容：一个顺序栈的数据类型表示和初始化、进栈、出栈基本运算。
四、实验环境：Windows XP + VC++6.0开发环境。
五、实验步骤：1、对顺序栈的知识进行复习，弄清楚栈的算法思想。
2、熟悉顺序栈的几种基本运算，即：（1）初始化栈int initStack(sqstack *s){/*创建一个空栈由指针S指出*/if ((s=(sqstack*)malloc(sizeof(sqstack)))= =NULL) return FALSE;s->top= -1;return TRUE;}（2）入栈操作int push(sqstack *s, Elemtype x){/*将元素x插入到栈s中，作为s的新栈顶*/if(s->top>=MAXNUM-1) return FALSE; /*栈满*/s->top++;s->stack[s->top]=x;return TRUE;}（3）出栈操作Elemtype pop(sqstack *s){/*若栈s不为空，则删除栈顶元素*/Elemtype x;if(s->top<0) return NULL; /*栈空*/x=s->stack[s->top];s->top--;return x;}（4）取栈顶元素操作Elemtype gettop(sqstack *s){/*若栈s不为空，则返回栈顶元素*/if(s->top<0) return NULL; /*栈空*/return (s->stack[s->top]);}取栈顶元素与出栈不同之处在于出栈操作改变栈顶指针top的位置，而取栈顶元素操作不改变栈的栈顶指针.（5）判栈空操作int Empty(sqstack *s){/*栈s为空时，返回为TRUE；非空时，返回为FALSE*/if(s->top<0) return TRUE;return FALSE;}（6）置空操作void setEmpty(sqstack *s){/*将栈s的栈顶指针top，置为-1*/s->top= -1;}3、上机调试。
顺序栈的实验报告
顺序栈的实验报告顺序栈的实验报告引言：顺序栈是一种常见的数据结构，它具有先进后出的特性，被广泛应用于计算机科学和软件工程领域。
本次实验旨在通过实际操作和观察，深入了解顺序栈的特点、操作和应用。
实验目的：1. 理解顺序栈的基本概念和特性；2. 掌握顺序栈的基本操作，包括入栈和出栈；3. 通过实验验证顺序栈的操作是否符合预期；4. 探索顺序栈在实际应用中的潜力和局限性。
实验过程：1. 实验环境准备：在本次实验中，我们使用C++语言编写程序来模拟顺序栈的操作。
实验环境包括一台计算机和一个集成开发环境（IDE），如Visual Studio等。
2. 顺序栈的定义：顺序栈是一种使用数组实现的栈结构，它具有固定大小和连续存储的特点。
栈顶指针指向栈顶元素，栈底指针指向栈底元素。
3. 顺序栈的基本操作：- 初始化栈：创建一个空栈，并初始化栈顶指针和栈底指针；- 判断栈是否为空：检查栈顶指针是否等于栈底指针；- 入栈操作：将元素插入到栈顶，并更新栈顶指针；- 出栈操作：删除栈顶元素，并更新栈顶指针；- 获取栈顶元素：返回栈顶元素的值，不修改栈的结构。
4. 实验步骤：- 步骤一：创建一个空栈；- 步骤二：依次将元素1、2、3入栈；- 步骤三：判断栈是否为空，并输出结果；- 步骤四：获取栈顶元素，并输出结果；- 步骤五：依次出栈，并输出结果。
实验结果：根据实验步骤和操作，我们得到以下结果：- 创建空栈成功；- 元素1、2、3成功入栈；- 栈非空，判断成功；- 获取栈顶元素为3，操作成功；- 依次出栈元素3、2、1，操作成功。
实验分析：通过实验结果可以看出，顺序栈的操作符合预期，各个操作均成功完成。
顺序栈的入栈和出栈操作都具有常数时间复杂度，即O(1)，因为只需更新栈顶指针即可。
而判断栈是否为空和获取栈顶元素的操作也是常数时间复杂度。
这些特点使得顺序栈在实际应用中具有高效性和可靠性。
然而，顺序栈也存在一些局限性。
首先，顺序栈的大小是固定的，一旦栈满无法再插入新元素。
栈和队列实验报告
数据结构实验报告顺序栈的实现和基本操作一、需求分析（1）顺序栈◆栈的典型操作是入栈和出栈，前者将新元素压入栈中，后者弹出栈顶元素。
栈只提供对栈顶元素的访问操作，由top ( )完成。
Push ( )和Pop ( )还有Top ( )共同构成了栈的最小功能接口。
此外，为了方便使用，栈还有判空，判满和输出栈等功能。
◆输入形式及范围：输入形式为整型，范围为0~65535。
◆输出形式：在顺序栈的初始化后显示初始化成功，在判断栈是否为空时显示当前栈为空，入栈后显示入栈成功或者栈已满。
出栈时显示出栈元素或者栈为空。
输出栈时依次显示栈中元素。
◆程序功能：初始化栈，判断栈是否为空，判断栈是否为满，入栈，出栈，取栈顶元素，出栈同时返回栈顶元素和输出栈等功能。
◆测试数据：初始化后输入栈的长度为4。
判断栈是否为空。
进行5次入栈操作。
分别输入1 2 3 4 5输出栈。
执行2次出栈操作。
输出栈。
查看栈顶元素。
输出栈。
（2）队列◆队列的典型操作是入队和出队，前者将新元素压入队列中，后者弹出队首头元素。
队列只提供对队头元素和队尾元素的操作，由DeQueue ( ) 和EnQueue( )完成。
DeQueue还有EnQueue ( )共同构成了队列的最小功能接口。
此外，为了方便使用，队列还有判空，判满和输出队列等功能。
◆输入形式及范围：输入形式为整型，范围为0~65535。
◆输出形式：在顺序队列的初始化后显示初始化成功，在判断队列是否为空时显示当前队列为空，入队列后显示入队成功或者队列已满。
出队列时显示出队首元素或者队列为空。
输出队列时依次显示队列中元素。
◆程序功能：初始化队列，判断队列是否为空，判断队列是否为满，入队，出队，取队首元素，输出队列等功能。
◆测试数据：初始化后输入队列的长度为54。
判断队列是否为空。
进行5次入队操作。
分别输入1 2 3 4 5输出队列。
执行2次出队操作。
输出队列。
查看队首元素。
输出队列。
二、概要设计（1）顺序栈◆为了实现程序的功能，在.H文件中定义了栈的模板类. template <class T>class Stack{私有数据成员：private:栈的最大长度int MaxSize;栈顶位置int top;顺序栈首地址T *theArray;公有成员：public:栈的初始化void InitStack(int capacity=10);操作结果：初始化一个默认长度为10的空栈判断栈是否为空bool IsEmpty() const;初始条件：栈已存在。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
if(!S.base) //存储分配失败
exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
{
int s;
if(operate=='+')
s=a+b;
if(operate=='-')
s=a-b;
if(operate=='*')
s=a*b;
if(operate=='/')
s=a/b;
return s;
}
Status In(SElemType c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='#'||c=='('||c==')')
}
Status Stackempty(SqStack &s)
{
if(s.base==s.top)
return OK;
else
return NO;
}
Status push_num(SqStack &s,int e)
{
if(s.top-s.base>=s.stacksize)
{
s.base=(SElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));
数据结构 实验三
课程数据结构实验名称顺序栈基本操作第页
专业班级学号
姓名
实验日期：年月日评分
一、实验目的
1．熟悉并能实现栈的定义和基本操作。
2．了解和掌握栈的应用。
二、实验要求
1．进行栈的基本操作时要注意栈"后进先出"的特性。
2．编写完整程序完成下面的实验内容并上机运行。
3．整理并上交实验报告。
三、实验内容
Status pushnum(SElemType num);
Status caculate(SElemType a,SElemType operate,SElemType b);
Status pop_operate(SqStack &s,SElemType &c);
Status change(SElemType e);
1．编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行清空、销毁、入栈、出栈以及取栈顶元素操作。
2．编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术表达式的值。
主要功能描述如下：
（1）从键盘上输入表达式。
（2）分析该表达式是否合法：
a)是数字，则判断该数字的合法性。若合法，则压入数据到堆栈中。
if(s.top==s.base)
return NO;
c=*--s.top;
return OK;
}
char GetTop(SqStack &s)
{
char c;
if(s.top==s.base)
return NO;
c=*(s.top-1);
return c;
}
Status caculate(int a,SElemType operate,int b)
}
return 0;
}
第二题：
#include<iostream>
using namespace std;
#define STACK_SIZE 100
#define STACKINCREMENT 10
#define OVERFLOW -1
#define OK 1
#define NO 0
typedef int Status;
第一题：
#include <iostream>
using namespace std;
#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量
#define OVERFLOW -1
#define OK 1
#define NO -1
}
Status DsetroyStack (SqStack &S)//销毁栈S
{
S.base=NULL;
return OK;
}
Status Push(SqStack &S,SElemType e)
//插入元素e为新的栈顶元素
{
if (S.top-S.base>=S.stacksize)
{
S.base=(SElemType *)realloc(S.base,
{
if (S.top==S.base)
return NO;
e=*(S.top-1);
return OK;
}//GetTop
int main()
{
SqStack S;
Initstack(S);
cout<<"输入要压到栈中的元素!"<<endl;
char c;
while((c=getchar())!='\n')
char Precede(SElemType a,SElemType b);
char Operatecxz();
int m;
m=Operatecxz();
cout<<m<<endl;
return 0;
}
Status change(SElemType e)
{
int m;
m=e-48;
return m;
}
*s.top++=e;
return OK;
}
Status pop_operate(SqStack &s,SElemType &c)
{
if(s.top==s.base)
return NO;
c=*--s.top;
return OK;
}
Status pop_num(SqStack &s,int &c)
{
if(b=='*'||b=='/'||b=='(')
return '<';
}
if(a=='*'||a=='/')
{
if(b=='+'||b=='-'||b==')'||b=='*'||b=='/'||b=='#')
return '>';
if(b=='(')
return '<';
}
if(a=='(')
char c,e,x;
int num,a,b,flat=1,sz=0;
return '>';
}
if(a=='#')
{
if(b=='#')
return '=';
if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(')
return '<';
if(b==')')
return ' ';
}
return ' ';
}
char Operatecxz()
{
SqStack Operate,Num;
{
Push(S,c);
}
GetTop(S,c);
cout<<"栈顶元素为："<<c<<endl;
//ClearStack (S);
//DsetroyStack(S);
for(int i=0;S.top!=S.base;i++)
{
Pop(S,c);
cout<<"栈中第"<<i+1<<"元素的值:";
cout<<c<<endl;
Status push_operate(SqStack &s,SElemType e);
Status push_num(SqStack &s,int e);
Status Stackempty(SqStack &s);
Status pop_num(SqStack &s,int &c);
Status pushoperate(SElemType operate);
{
s.base=(SElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s.base)
exit(OVERFLOW);
s.top=s.base+s.stacksize;