数据结构实验---堆栈
堆栈模拟队列实验报告
一、实验目的通过本次实验，加深对堆栈和队列数据结构的理解，掌握堆栈的基本操作，并学会利用堆栈模拟队列的功能。
通过实验，培养学生的编程能力和问题解决能力。
二、实验内容1. 实现一个顺序堆栈，包括初始化、判断是否为空、入栈、出栈等基本操作。
2. 利用两个顺序堆栈实现队列的功能，包括入队、出队、判断队列是否为空等操作。
3. 通过实例验证模拟队列的正确性。
三、实验原理队列是一种先进先出（FIFO）的数据结构，而堆栈是一种后进先出（LIFO）的数据结构。
本实验通过两个堆栈来实现队列的功能。
当元素入队时，将其压入第一个堆栈（称为栈A）；当元素出队时，先从栈A中依次弹出元素并压入第二个堆栈（称为栈B），直到弹出栈A中的第一个元素，即为队首元素。
四、实验步骤1. 定义堆栈的数据结构，包括堆栈的最大容量、当前元素个数、堆栈元素数组等。
2. 实现堆栈的基本操作，包括初始化、判断是否为空、入栈、出栈等。
3. 实现模拟队列的功能，包括入队、出队、判断队列是否为空等。
4. 编写主函数，创建两个堆栈，通过实例验证模拟队列的正确性。
五、实验代码```c#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} SeqStack;// 初始化堆栈void InitStack(SeqStack S) {S->top = -1;}// 判断堆栈是否为空int IsEmpty(SeqStack S) {return S->top == -1;}// 入栈int Push(SeqStack S, int x) {if (S->top == MAX_SIZE - 1) { return 0; // 堆栈已满}S->data[++S->top] = x;return 1;}// 出栈int Pop(SeqStack S, int x) {if (IsEmpty(S)) {return 0; // 堆栈为空}x = S->data[S->top--];return 1;}// 队列的入队操作void EnQueue(SeqStack S, SeqStack Q, int x) { Push(S, x);}// 队列的出队操作int DeQueue(SeqStack S, SeqStack Q, int x) { if (IsEmpty(Q)) {while (!IsEmpty(S)) {int temp;Pop(S, &temp);Push(Q, temp);}}if (IsEmpty(Q)) {return 0; // 队列为空}Pop(Q, x);return 1;}int main() {SeqStack S, Q;int x;InitStack(&S);InitStack(&Q);// 测试入队操作EnQueue(&S, &Q, 1);EnQueue(&S, &Q, 2);EnQueue(&S, &Q, 3);// 测试出队操作while (DeQueue(&S, &Q, &x)) {printf("%d ", x);}return 0;}```六、实验结果与分析1. 通过实例验证，模拟队列的入队和出队操作均正确实现了队列的先进先出特性。
实验报告堆栈操作
一、实验目的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）判断堆栈是否为空，结果为“否”。
六、实验结论通过本次实验，我们掌握了堆栈的基本概念、原理和操作。
国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
x=Pop(s); /*出栈*/
printf("%d ",x);
InQueue(sq,x); /*入队*/
}
printf("\n");
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
ElemType Pop(SeqStack *s); /*出栈*/
ElemType GetTop(SeqStack *s); /*取栈顶元素*/
void DispStack(SeqStack *s); /*依次输出从栈顶到栈底的元素*/
void DispBottom(SeqStack *s); /*输出栈底元素*/
} SeqQueue; /*定义顺序队列*/
void InitStack(SeqStack *s); /*初始化栈*/
int StackEmpty(SeqStack *s); /*判栈空*/
int StackFull(SeqStack *s); /*判栈满*/
void Push(SeqStack *s,ElemType x); /*进栈*/
sq=(SeqQueue *)malloc(sizeof(SeqQueue));
InitQueue(sq);
printf("(8)队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
printf("(9)出栈/入队的元素依次为:");
北京交通大学-数据结构上机实验-2
数据结构上机实验二实验内容:栈和链队列的基本操作实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对堆栈和队列的理解.实验要求:1) 栈和队列的显示要作为函数被调用.2) 把自己使用的栈和队列结构明确的表达出来.分组要求：可单独完成，也可两人一组。
评分标准：1) 只完成第一或第二题，3分；2）完成一和二题，得5分；3）在2）基础上，可选做三）中的题目。
题目:一)堆栈题（顺序栈）:创建一个栈+入栈+出栈(1)由键盘一个一个的输入正整数，建立相应的堆栈，输入-1时，堆栈结束；(2)在（1）中创建的堆栈中添加一个元素；(3)在（1）中创建的堆栈中删除一个元素；(要求在显示器可见)；#include<stdio.h>#include<stdlib.h>#include <string>#define OK 1#define ERROR 0#define Status int#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct Stack{int *base;int *top;Status stacksize;}SqStack;Status CreatStack(SqStack &S) //创建空栈{S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status InStack(SqStack &S) //创建栈元素{int e;printf("请输入初始栈元素:\n");scanf("%d",&e);while(e!=-1){if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;scanf("%d",&e);}return OK;}Status Push(SqStack &S,int e) //栈加元素{if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,int e) //栈中删除元素{if(S.top==S.base) return ERROR;e=*--S.top;printf("\n请输出出栈元素:%d",e);printf("\n");return OK;}void print(){printf("\n菜单：");printf("\n1.由键盘一个一个的输入正整数，建立相应的堆栈，输入-1时，堆栈结束：");printf("\n2.在创建的堆栈中添加一个元素：");printf("\n3.在创建的堆栈中删除一个元素：");printf("\n3.退出");}void printS(SqStack &S) //打印堆栈{int *p;printf("请输出堆栈中的元素:\n");for(p=S.base;p<S.top;p++){printf("%d ",*p);}}void main() //主程序{SqStack S;int e,choice;do{print();printf("\n请输入选项：");scanf("%d",&choice);switch(choice){case 1:if(CreatStack(S)==1){if(InStack(S)==1)printS(S);}break;case 2:printf("\n请输入入栈元素：");scanf("%d",&e);Push(S,e);printS(S);break;case 3:Pop(S,e);printS(S);break;case 4:exit(0);break;}}while(1);}二)链队列题目：初始化队列+入队列+出队列+销毁队列(1)初始化一个链队列；(2)在初始化好的链队列中放入数，入队列，完成后要求显示；(3)从队列中出队列，要求显示出来的元素和之后的队列；(4)销毁创建的队列，释放内存；#include <stdio.h>#include <malloc.h>typedef struct Qnode{//队列结点int data;struct Qnode *next;}QNode, *QueuePtr;typedef struct {QueuePtr front; //队头指针QueuePtr rear; //队尾指针}LinkQueue;void InitQueue(LinkQueue &Q){ //初始化链队列Q.front=Q.rear=(QueuePtr) malloc(sizeof(QNode));Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int e){//入队列QueuePtr p;while(e!=-1){p=(QueuePtr)malloc(sizeof(QNode));p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;scanf("%d",&e);}}int QueueLength (LinkQueue Q){//求队列长度QueuePtr p;p=Q.front->next; //p指向队头int i=1;while(p!=Q.rear){ //遍历链队列,统计结点数i++;p=p->next;}return i;}// QueueLengthvoid DeQueue(LinkQueue &Q){ //出队列QueuePtr p;int e;if(Q.front==Q.rear)printf("The queue is empty\n");else{p=Q.front->next;e=p->data;printf("The delete elem is:%d\n",e);Q.front->next=p->next;if(Q.rear==p) Q.rear=Q.front;free(p);}printf("The new queue is :\n");}void DestroyQueue(LinkQueue &Q){ //销毁队列while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}}void QueueTraverse (LinkQueue Q){//遍历显示队列QueuePtr p;for(p=Q.front->next;p!=Q.rear;p=p->next)printf("%d ",p->data);printf("%d ",p->data);}void main(){LinkQueue Q;int e;InitQueue(Q);printf("Put in the elems:\n");scanf("%d",&e);EnQueue(Q,e);printf("The queue is:\n");QueueTraverse(Q);printf("\n");DeQueue(Q);QueueTraverse(Q);printf("\n");DestroyQueue(Q);}三）应用题（1）编制程序，将输入的十进制数据M 转换为八进制数据M8，将其调试通过。
堆栈的实验报告
一、实验目的1. 理解堆栈的基本概念和原理；2. 掌握堆栈的顺序存储和链式存储方法；3. 熟悉堆栈的基本操作，如入栈、出栈、判断栈空、求栈顶元素等；4. 能够运用堆栈解决实际问题。
二、实验内容1. 堆栈的基本概念和原理；2. 堆栈的顺序存储和链式存储方法；3. 堆栈的基本操作实现；4. 堆栈的应用实例。
三、实验原理1. 堆栈的基本概念和原理：堆栈是一种特殊的线性表，它按照“后进先出”（LIFO）的原则组织数据。
即最后进入堆栈的数据元素最先出栈。
2. 堆栈的顺序存储方法：使用一维数组实现堆栈，栈顶指针top指向栈顶元素。
3. 堆栈的链式存储方法：使用链表实现堆栈，每个节点包含数据域和指针域。
4. 堆栈的基本操作实现：（1）入栈：将元素插入到栈顶，如果栈未满，则top指针加1，并将元素值赋给top指向的元素。
（2）出栈：删除栈顶元素，如果栈不为空，则将top指向的元素值赋给变量，并将top指针减1。
（3）判断栈空：如果top指针为-1，则表示栈为空。
（4）求栈顶元素：如果栈不为空，则将top指向的元素值赋给变量。
四、实验步骤1. 使用顺序存储方法实现堆栈的基本操作；2. 使用链式存储方法实现堆栈的基本操作；3. 编写程序，测试堆栈的基本操作是否正确；4. 分析实验结果，总结实验经验。
五、实验结果与分析1. 使用顺序存储方法实现堆栈的基本操作：（1）入栈操作：当栈未满时，将元素插入到栈顶。
（2）出栈操作：当栈不为空时，删除栈顶元素。
（3）判断栈空：当top指针为-1时，表示栈为空。
（4）求栈顶元素：当栈不为空时，返回top指向的元素值。
2. 使用链式存储方法实现堆栈的基本操作：（1）入栈操作：创建新节点，将其作为栈顶元素，并修改top指针。
（2）出栈操作：删除栈顶元素，并修改top指针。
（3）判断栈空：当top指针为NULL时，表示栈为空。
（4）求栈顶元素：返回top指针指向的节点数据。
3. 实验结果分析：通过实验，验证了顺序存储和链式存储方法实现的堆栈基本操作的正确性。
实验二 堆栈和队列基本操作的编程实现
HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY
数据结构
实验报告
实验二堆栈和队列基本操作的编程实现
【实验目的】
堆栈和队列基本操作的编程实现
要求：
堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
【实验性质】
验证性实验（学时数：2H）
【实验内容】
内容：把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。
可以实验一的结果自己实现数据输入、数据显示的函数。
利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。
【注意事项】
1.开发语言：使用C。
2.可以自己增加其他功能。
【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)。
堆栈实验报告
堆栈实验报告堆栈实验报告引言：堆栈是一种常见的数据结构，它具有先进后出（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. 堆栈的应用范围广泛，如函数调用、表达式求值等。
实验总结：通过本次实验，我们深入了解了堆栈的原理和应用。
堆栈作为一种重要的数据结构，在计算机科学领域中具有广泛的应用。
它不仅可以用于数据的存储和检索，还可以用于解决实际问题中的一些复杂计算和操作。
通过实际操作和观察，我们更加清晰地认识到堆栈的特点和优势。
然而，本次实验只是对堆栈的初步认识和应用，还有许多深入的研究和探索可以展开。
例如，我们可以进一步研究堆栈的实现原理和性能优化，探索堆栈在不同领域的应用案例，以及与其他数据结构的比较和结合等。
堆栈进制转换实验报告
一、实验目的1. 理解堆栈的基本原理和操作。
2. 掌握利用堆栈实现进制转换的方法。
3. 提高编程能力，培养问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理进制转换是将一个数从一种进制表示转换为另一种进制表示的过程。
例如，将十进制数转换为二进制数、十六进制数等。
堆栈是一种先进后出（FILO）的数据结构，可以用来实现进制转换。
进制转换的原理如下：1. 将十进制数转换为任意进制数，需要不断除以目标进制，直到商为0。
2. 将每次除法得到的余数存储在堆栈中，最后从堆栈中取出余数，倒序输出即为转换后的结果。
四、实验步骤1. 定义一个堆栈结构体，包含栈顶指针、栈底指针、栈大小和栈元素。
2. 实现堆栈的基本操作，如初始化、入栈、出栈和判断是否为空。
3. 编写进制转换函数，将十进制数转换为任意进制数。
4. 编写主函数，实现用户输入、进制转换和输出转换结果。
五、实验代码```cpp#include <iostream>#include <stack>using namespace std;// 堆栈结构体定义template <typename T>struct Stack {T base;T top;int size;int capacity;};// 初始化堆栈template <typename T>void initStack(Stack<T>& s, int capacity) { s.base = new T[capacity];s.top = s.base;s.size = 0;s.capacity = capacity;}// 入栈template <typename T>bool push(Stack<T>& s, T element) {if (s.size >= s.capacity) {return false;}s.top = element;s.top++;s.size++;return true;}// 出栈template <typename T>bool pop(Stack<T>& s, T& element) { if (s.size <= 0) {return false;}s.top--;element = s.top;s.size--;return true;}// 判断堆栈是否为空template <typename T>bool isEmpty(Stack<T>& s) {return s.size == 0;}// 十进制数转换为任意进制数template <typename T>void decimalToBase(T decimal, int base) { stack<T> resultStack;while (decimal > 0) {resultStack.push(decimal % base); decimal /= base;}while (!resultStack.empty()) {T element;pop(resultStack, element);cout << element;}cout << endl;}int main() {int decimal;int base;cout << "请输入十进制数：";cin >> decimal;cout << "请输入目标进制（2-16）："; cin >> base;if (base < 2 || base > 16) {cout << "目标进制无效！" << endl;return 0;}cout << "转换后的" << base << "进制数为：";decimalToBase(decimal, base);return 0;}```六、实验结果与分析1. 当输入十进制数65和进制8时，程序输出101，符合预期。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
strcat(Tempdata,Dr); //将两个字符串相接
c++; //指向下一个字符
if(In(*c,OPSET)){ //是运算符则执行
data=(float)atof(Tempdata);//字符串转化为浮点数
OPND.push(data); //将数据压入操作数堆栈OPND
if(e=='(') {
mystack.pop;//若e是字符'('则栈顶元素出栈
break;
}
else{ //若e不是字符'('则marth=ERROR
marth=ERROR;
break;
}
}
};break;
case']': //是字符']'
if(mystack.top()==0) //堆栈mystack栈顶是否为空
}
retuห้องสมุดไป่ตู้n 0;
}
//基于运算符优先关系并非返回比较结果符
char precede(char Aop, char Bop)
{
return prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];
}
//执行表达式求值函数
float Evaluate(char* Exp){
case '*':return (a*b);
case '/':return (a/b);
default :return 0;
}
}
Status In(char Test,char* TestOp) //判断输入字符是否为运算符
{
bool find=false; //布尔变量判断
for (int i=0; i < OPSETSIZE; i++)
#include <cstdio>
#include <stack>
using namespace std;
#define OK 0
#define ERROR -1
#define OVERFLOW -1
#define STACK_INIT_SIZE 100 //初始分配栈空间
#define STACKINCREMENT 10 //栈空间分配增量
c=Exp; //cp指向表达式
strcpy(Tempdata,"\0"); //让Tempdata变成一个字符串；
while (*c != '#' || OPTR.top() != '#'){ //遇到两个'#'，表达式求值完毕
if (!In(*c,OPSET)){ //不是运算符则执行
Dr[0]=*c; //该字符放入Dr
scanf("%s",&EXP);
result=Evaluate(EXP); //执行表达式运算
printf("运算结果：%.4f\n",result);
printf("\n");
}
---------------------------------------------------------------------------------------------------------------
1、学习堆栈例程代码
2、学习后缀表达式计算的例程，掌握C++自带的STL栈的应用方法
3、根据实验要求，分析例程中关键代码的功能，进行代码说明
4、根据实验要求，尝试使用STL栈编写程序实现新功能，进行代码分析和结果说明。
二、方法、步骤：
1、阅读表达式例程，完成以下代码分析
a)对变量定义区的变量，说明它们的含义
/*****************函数实现*********************/
float Operate(float a,unsigned theta,float b) //运算函数
{
switch(theta){
case '+':return (a+b);
case '-':return (a-b);
mystack.push(exp[i]);break;
case')': //是字符')'
{
if(mystack.top()==0) //堆栈mystack栈顶是否为空
{
marth=ERROR; //空则marth=ERROR
break;
}
else
{ e=mystack.top(); //把栈顶元素赋给变量e
StackChar OPTR; //定义一个堆栈类对象用来存放操作符
StackFloat OPND; //定义一个堆栈类对象用来存放操作数
char Tempdata[20];
float data,a,b,r; //用作中间变量
char theta,*c,Dr[2]; //用作中间变量
OPTR.push('#'); //符号栈底压入‘#’
unsigned char prior[7][7] = { //定义运算符的优先级
'>','>','<','<','<','>','>',
'>','>','<','<','<','>','>',
'>','>','>','>','<','>','>',
'>','>','>','>','<','>','>',
'<','<','<','<','<','=',' ',
'>','>','>','>',' ','>','>',
'<','<','<','<','<',' ','='
};
char OPSET [OPSETSIZE]={'+' , '-' , '*' , '/' , '(' , ')' , '#'};//可能出现的运算符
char e,exp[100]; //e为中间变量，方便判断栈顶元素
int i,marth=OK; //marth作为标志符
printf("请输入有括号符的表达式:\n");
scanf("%s",exp);
mystack.push(0); //栈底赋值零，以便判断是否匹配成功：最后mystack.top()是否为零。
case '=': //如果优先级相等即遇到右括符
OPTR.pop();
c++;
break;
case '>': //优先级关系为大于，进行运算操作
theta = OPTR.top(); //栈顶运算符传递给变量theta
OPTR.pop(); //弹出栈顶运算符
b=OPND.top(); //栈顶操作数传递给变量b
strcpy(Tempdata,"\0"); //Tempdata赋予空字符以备下次使用
}
}
else{
switch (precede(OPTR.top(),*c)){ //比较运算符堆栈栈顶和刚接到运算符的优先级
case '<': //若优先级是小于则压入运算符
OPTR.push(*c);
c++;
break;
#define OPSETSIZE 7
typedef int Status;
typedef stack<char>StackChar; //用新的类名字StackCharr定义为Char类型
typedef stack<float> StackFloat; //用新的类名字StackFloat定义为Float类型
#define ERROR 0
typedef stack<char>StackChar; //用新的类名字StackCharr定义为Char类型
/******************主函数**************************/
int main()
{
StackChar mystack; //建立堆栈
return OPND.top(); //返回表达式计算结果
}
/******************主函数**************************/