C语言 栈 求表达式
数据结构——用C语言描述(第3版)教学课件第3章 栈和队列
if(S->top==-1) /*栈为空*/
return(FALSE);
else
{*x = S->elem[S->top];
return(TRUE);
}
返回主目录}[注意]：在实现GetTop操作时，也可将参数说明SeqStack *S 改为SeqStack S，也就是将传地址改为传值方式。传 值比传地址容易理解，但传地址比传值更节省时间、 空间。
返回主目录
算法:
void BracketMatch(char *str) {Stack S; int i; char ch; InitStack(&S); For(i=0; str[i]!='\0'; i++) {switch(str[i])
{case '(': case '[': case '{':
3.1.3 栈的应用举例
1. 括号匹配问题
思想：在检验算法中设置一个栈，若读入的是左括号， 则直接入栈，等待相匹配的同类右括号；若读入的是 右括号，且与当前栈顶的左括号同类型，则二者匹配， 将栈顶的左括号出栈，否则属于不合法的情况。另外， 如果输入序列已读尽，而栈中仍有等待匹配的左括号， 或者读入了一个右括号，而栈中已无等待匹配的左括 号，均属不合法的情况。当输入序列和栈同时变为空 时，说明所有括号完全匹配。
return(TRUE);
}
返回主目录
【思考题】
如果将可利用的空闲结点空间组织成链栈来管理，则申 请一个新结点（类似C语言中的malloc函数）相当于链 栈的什么操作？归还一个无用结点（类似C语言中的 free函数）相当于链栈的什么操作？试分别写出从链栈 中申请一个新结点和归还一个空闲结点的算法。
(完整版)数学表达式计算(c语言实现)
一、设计思想计算算术表达式可以用两种方法实现:1.中缀转后缀算法此算法分两步实现：先将算术表达式转换为后缀表达式，然后对后缀表达式进行计算.具体实现方法如下:（1）中缀转后缀需要建一个操作符栈op和一个字符数组exp,op栈存放操作符，字符数组用来存放转换以后的后缀表达式。
首先，得到用户输入的中缀表达式,将其存入str数组中。
对str数组逐个扫描，如果是数字或小数点,则直接存入exp数组中，当扫描完数值后,在后面加一个＃作为分隔符。
如果是操作符，并且栈为空直接入栈，如果栈不为空，与栈顶操作符比较优先等级，若比栈顶优先级高，入栈；如果比栈顶优先级低或相等，出栈将其操作符存到exp数组中，直到栈顶元素优先等级低于扫描的操作符，则此操作符入栈；如果是左括号，直接入栈，如果是右括号，出栈存入exp数组,直到遇到左括号，左括号丢掉。
然后继续扫描下一个字符,直到遇到str中的结束符号\0，扫描结束。
结束后看op栈是否为空，若不为空，继续出栈存入exp数组中，直到栈为空.到此在exp数组最后加结束字符\0。
我们就得到了后缀表达式。
（2）后缀表达式计算此时需要一个数值栈od来存放数值。
对exp数组进行逐个扫描，当遇到数字或小数点时，截取数值子串将其转换成double类型的小数，存入od栈中。
当遇到操作符，从栈中取出两个数，进行计算后再放入栈中。
继续扫描,知道扫描结束,此时值栈中的数值就是计算的结果,取出返回计算结果。
2。
两个栈实现算法此算法需要两个栈，一个值栈od，一个操作符栈op。
将用户输入的数学表达式存入str数组中,对其数组进行逐个扫描。
当遇到数字或小数点，截取数值子串，将其转换成double类型的数值存入od栈中；当遇到左括号，直接入op栈；遇到右括号，op栈出栈，再从值栈od中取出两个数值，计算将其结果存入值栈中,一直进行此操作，直到操作符栈栈顶为左括号，将左括号丢掉。
如果遇到操作符，若op栈为空，直接入栈;若栈不为空，与栈顶元素比较优先等级,若比栈顶操作符优先等级高，直接入op栈,如果低于或等于栈顶优先等级，op栈出栈,再从值栈中取出两个数值，计算将其结果存入值栈中，一直进行此操作，直到栈顶优先等级低于扫描的操作符等级，将此操作符入op 栈。
c语言栈计算表达式
c语言栈计算表达式在计算机科学中，栈是一种非常重要的数据结构，被广泛应用于编译器、操作系统、网络通信等领域。
在本文中，我们将探讨如何使用C语言实现栈来计算表达式。
表达式是由操作数、操作符和括号组成的数学式子，例如：3 + 4 * 2 / (1 - 5)。
在计算表达式时，我们需要遵循一定的计算规则，如乘除法优先于加减法，括号内的计算优先于括号外的计算等。
我们可以使用栈来实现对表达式的计算。
具体步骤如下：1. 定义两个栈：一个操作数栈和一个操作符栈。
2. 从左到右遍历表达式的每一个字符，如果是数字则将其压入操作数栈；如果是操作符则将其压入操作符栈，并根据运算规则进行计算。
3. 在遍历完成后，操作符栈中可能还有未计算的操作符，需要继续计算，直到操作符栈为空。
4. 最终操作数栈中只剩下一个数，即为表达式的计算结果。
下面是一段示例代码，用于计算简单的表达式：```#include <stdio.h>#include <stdlib.h>#include <ctype.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;void initStack(Stack *s) {s->top = -1;}void push(Stack *s, int item) { if (s->top == MAX_SIZE - 1) { printf('Stack Overflow');exit(1);}s->data[++s->top] = item;}int pop(Stack *s) {if (s->top == -1) {printf('Stack Underflow');exit(1);}return s->data[s->top--];}int isEmpty(Stack *s) {return s->top == -1;}int isFull(Stack *s) {return s->top == MAX_SIZE - 1;}int peek(Stack *s) {return s->data[s->top];}int evaluate(char *expr) {Stack operandStack, operatorStack; initStack(&operandStack);initStack(&operatorStack);int i = 0;while (expr[i] != '0') {if (isdigit(expr[i])) {int num = 0;while (isdigit(expr[i])) {num = num * 10 + (expr[i] - '0'); i++;}push(&operandStack, num);}else if (expr[i] == '(') {push(&operatorStack, expr[i]);i++;}else if (expr[i] == ')') {while (!isEmpty(&operatorStack) && peek(&operatorStack) != '(') {int op2 = pop(&operandStack);int op1 = pop(&operandStack);char op = pop(&operatorStack);int result;switch (op) {case '+':result = op1 + op2;break;case '-':result = op1 - op2;break;case '*':result = op1 * op2;break;case '/':result = op1 / op2;break;}push(&operandStack, result);}pop(&operatorStack);i++;}else if (expr[i] == '+' || expr[i] == '-' || expr[i] == '*' || expr[i] == '/') {while (!isEmpty(&operatorStack) &&peek(&operatorStack) != '(' &&((expr[i] == '*' || expr[i] == '/') || (expr[i] == '+' || expr[i] == '-') &&(peek(&operatorStack) == '*' || peek(&operatorStack) == '/'))) {int op2 = pop(&operandStack);int op1 = pop(&operandStack);char op = pop(&operatorStack);int result;switch (op) {case '+':result = op1 + op2;break;case '-':result = op1 - op2;break;case '*':result = op1 * op2;break;case '/':result = op1 / op2;break;}push(&operandStack, result); }push(&operatorStack, expr[i]); i++;}else {i++;}}while (!isEmpty(&operatorStack)) { int op2 = pop(&operandStack);int op1 = pop(&operandStack);char op = pop(&operatorStack);int result;switch (op) {case '+':result = op1 + op2;break;case '-':result = op1 - op2;break;case '*':result = op1 * op2;break;case '/':result = op1 / op2;break;}push(&operandStack, result);}return pop(&operandStack);}int main() {char expr[MAX_SIZE];printf('Enter an expression: ');fgets(expr, MAX_SIZE, stdin);int result = evaluate(expr);printf('Result = %d', result);return 0;}```在这段代码中，我们定义了一个栈结构体，包含了栈的数据和栈顶指针。
c语言栈实验总结
c语言栈实验总结在实验中，我们使用C语言编写了栈的相关代码，并进行了多个测试和验证。
通过这些实验，我们对栈的基本特征、操作和应用有了更深入的理解。
我们需要明确栈的定义和特点。
栈是一种具有特定限制的线性数据结构，它的特点是“后进先出”（Last In First Out，LIFO）。
这意味着在栈的操作中，最后一个进入栈的元素将首先被访问和操作，而之前的元素则需要等待。
在实验中，我们首先实现了栈的基本操作，包括创建栈、入栈、出栈和判断栈是否为空。
通过这些操作，我们可以有效地管理栈中的元素，并根据需要进行添加和删除。
接下来，我们进行了一系列的测试和验证，以确保栈的操作和功能的正确性。
我们通过不同的测试用例，模拟了各种情况下的栈操作，包括正常情况下的入栈和出栈、栈的空和满状态的判断，以及异常情况下的错误处理。
通过这些测试，我们可以验证栈的实现是否符合预期，并检查代码中是否存在潜在的问题。
在实验过程中，我们还探讨了栈的应用场景和实际用途。
栈的一个典型应用是函数调用过程中的函数调用栈。
当一个函数被调用时，其局部变量和返回地址等信息被压入栈中，当函数执行完毕后，这些信息再从栈中被弹出，使得程序可以正确地返回到原来的调用点。
通过理解函数调用栈的原理和实现，我们可以更好地理解函数调用的工作原理，并能更好地处理函数之间的交互和数据传递。
栈还可以用于解决一些特定的问题，如括号匹配、逆波兰表达式求值等。
通过使用栈，我们可以方便地处理这些问题，并提高程序的效率和可读性。
总结来说，通过C语言栈的实验，我们深入了解了栈的概念、操作和应用，掌握了栈的基本原理和使用方法。
在实验中，我们通过编写代码、进行测试和验证，验证了栈的正确性，并探讨了栈的应用场景和实际用途。
通过这些实验，我们不仅提高了对栈的理解和掌握，还培养了我们的编程能力和问题解决能力。
希望通过这些实验，我们可以更好地应用栈的知识，解决实际问题，并在以后的学习和工作中取得更好的成果。
c语言实现中缀表达式的计算
c语言实现中缀表达式的计算C语言实现中缀表达式的计算一、前言在计算机科学领域，中缀表达式是最容易理解的数学表达式，也是人们最常用的表达方式。
但对于计算机而言，中缀表达式并不方便计算。
因此，在进行表达式计算时，需要将中缀表达式转化为其它形式，例如前缀表达式和后缀表达式。
在本篇文章里，我们将介绍如何使用C语言实现中缀表达式的计算。
二、中缀表达式的转换在C语言中，实现中缀表达式的计算，通常需要先将中缀表达式转换为后缀表达式。
中缀表达式的转换过程主要分为以下三个步骤：1. 初始化一个栈，存储操作符。
2. 遍历中缀表达式，根据操作符的运算优先级将其从中缀表达式转化为后缀表达式。
3. 根据后缀表达式，使用栈实现表达式的计算。
其中，第二步是最关键的一个步骤。
我们可以通过以下方法进行转换：1. 将操作数直接输出。
2. 如果遇到运算符，先将栈中所有优先级大于等于该运算符的操作符弹出，再将该运算符入栈。
3. 如果遇到左括号，直接入栈。
4. 如果遇到右括号，将栈中的元素一直弹出到遇到左括号为止。
例如，对于中缀表达式2 + 3 * 4 - 5，转换为后缀表达式的过程如下所示：中缀表达式：2 + 3 * 4 - 5转换为后缀表达式：2 3 4 * + 5 -三、代码实现现在，我们已经掌握了中缀表达式的转换方法，接下来，我们就可以实现C语言代码了。
具体实现如下：#include <stdio.h>#include <stdlib.h>#include <string.h>// 定义运算符栈char op_stack[100];// 定义数字栈int num_stack[100];// 定义存储后缀表达式的数组char postfix[100];// 定义存储后缀表达式的栈顶指针int postIndex = 0;// 获取优先级int getPriority(char op){switch(op){case '+':case '-':return 1;case '*':case '/':return 2;case '(':case ')':return 0;}return -1;}// 中缀表达式转换为后缀表达式void infixToPostfix(char* infix){// 定义中缀表达式的指针char* ptr = infix;// 定义操作符栈顶指针int opTop = 0;while(*ptr != '\0'){if(*ptr >= '0' && *ptr <= '9') // 如果是数字，直接存入后缀表达式{postfix[postIndex++] = *ptr;}else if(*ptr == '(') // 如果是左括号，先入栈{op_stack[opTop++] = *ptr;}else if(*ptr == ')') // 如果是右括号，将栈中元素全部弹出{while(op_stack[opTop-1] != '('){postfix[postIndex++] = op_stack[--opTop];}opTop--;}else // 如果是运算符{while(opTop > 0 && getPriority(op_stack[opTop-1]) >= getPriority(*ptr)) // 将栈中优先级大于等于当前运算符的元素全部弹出{postfix[postIndex++] = op_stack[--opTop];}op_stack[opTop++] = *ptr; // 将当前运算符入栈}ptr++;}while(opTop > 0) // 将栈中剩余运算符全部弹出{postfix[postIndex++] = op_stack[--opTop];}}// 计算后缀表达式int calculate(char* postfix){// 定义后缀表达式的指针char* ptr = postfix;// 定义数字栈顶指针int numTop = 0;while(*ptr != '\0'){if(*ptr >= '0' && *ptr <= '9') // 如果是数字，直接入栈{num_stack[numTop++] = *ptr - '0';}else // 如果是运算符{int num2 = num_stack[--numTop];int num1 = num_stack[--numTop];switch(*ptr){case '+':num_stack[numTop++] = num1 + num2;break;case '-':num_stack[numTop++] = num1 - num2;break;case '*':num_stack[numTop++] = num1 * num2;break;case '/':num_stack[numTop++] = num1 / num2;break;}}ptr++;}return num_stack[0];}// 测试函数void test(char* infix){printf("中缀表达式：%s\n", infix);infixToPostfix(infix);printf("后缀表达式：%s\n", postfix);int result = calculate(postfix);printf("计算结果：%d\n", result);printf("--------------------------\n");}// 主函数int main(){test("2 + 3 * 4 - 5");test("3 + 4 * 2 / (1 - 5) ^ 2");return 0;}四、总结通过以上代码实现，我们可以看到中缀表达式的计算过程，其实就是将中缀表达式转化为后缀表达式的过程，并使用栈进行计算。
c语言入栈出栈代码
c语言入栈出栈代码C语言是一种广泛使用的编程语言，它具有高效、简洁、灵活等特点，因此在计算机科学领域中得到了广泛的应用。
在C语言中，入栈出栈是一种非常重要的操作，它可以帮助我们实现很多有用的功能。
本文将介绍C语言中的入栈出栈操作，并提供一些示例代码，帮助读者更好地理解这些操作。
一、什么是栈在介绍入栈出栈操作之前，我们需要先了解一下什么是栈。
栈是一种数据结构，它具有后进先出（LIFO）的特点。
也就是说，最后进入栈的元素最先被取出。
栈可以用数组或链表来实现，但是数组实现的栈比较简单，因此我们在本文中只介绍数组实现的栈。
二、栈的基本操作栈的基本操作包括入栈和出栈。
入栈操作将一个元素压入栈中，出栈操作将栈顶元素弹出。
下面是栈的基本操作的代码实现：```c#define MAXSIZE 100 // 栈的最大容量typedef struct {int data[MAXSIZE]; // 栈的数据int top; // 栈顶指针} Stack;// 初始化栈void initStack(Stack *s) {s->top = -1;}// 判断栈是否为空int isEmpty(Stack *s) {return s->top == -1;}// 判断栈是否已满int isFull(Stack *s) {return s->top == MAXSIZE - 1; }// 入栈操作void push(Stack *s, int x) {if (isFull(s)) {printf("Stack is full.\n");return;}s->top++;s->data[s->top] = x;}// 出栈操作int pop(Stack *s) {if (isEmpty(s)) {printf("Stack is empty.\n");return -1;}int x = s->data[s->top];s->top--;return x;}```在上面的代码中，我们定义了一个结构体Stack，它包含一个数组data和一个指针top。
C语言数据结构_第04讲 栈
while(n); printf("转换后的二进制数值为："); while(s.top) // 余数出栈处理 { printf("%d",s.top->data); // 输出栈顶的余数 stacknode* p=s.top; // 修改栈顶指针 s.top=s.top->next; delete p; // 回收一个结点，C语言中用free p } }
3-3-2 表达式求值
表达式是由运算对象、运算符、括号等组成的有意义的式子。 1．中缀表达式（Infix Notation） 一般我们所用表达式是将运算符号放在两运算对象的中 间，比如：a+b，c/d等等，我们把这样的式子称为中缀表达 式。 2．后缀表达式（Postfix Notation） 后缀表达式规定把运算符放在两个运算对象（操作数） 的后面。在后缀表达式中，不存在运算符的优先级问题，也 不存在任何括号，计算的顺序完全按照运算符出现的先后次 次序进行。 3．中缀表达式转换为后缀表达式 其转换方法采用运算符优先算法。转换过程需要两个栈： 一个运算符号栈和一个后缀表达式输出符号栈。
（4）读栈顶元素
datatype ReadTop（SeqStack *s） { if (SEmpty ( s ) ) return 0； // 若栈空，则返回0 else return (s->data[s->top] )；
// 否则，读栈顶元素，但指针未移动
}
（5）判栈空
int SEmpty（SeqStack *s） { if （s->top= = –1） return 1； else return 0； }
2．顺序栈运算的基本算法 （1）置空栈 首先建立栈空间，然后初始化栈顶指针。 SeqStack *Snull（） { SeqStack *s； s=new (SeqStack)；
用栈解决表达式求值问题的c语言代码
栈是一种常见的数据结构，用于解决许多算法和数据处理问题。
在编程中，栈通常用于处理表达式求值问题。
本篇文章将介绍如何使用栈解决表达式求值问题，并给出对应的C语言代码。
1. 表达式求值问题介绍表达式求值是指计算一个数学表达式的值，通常涉及到四则运算、括号和优先级等概念。
给定一个表达式“3 + 4 * 2”，我们需要得到其计算结果为11。
在编程中，需要将该表达式转换为计算机可识别的形式，并使用算法进行求值。
2. 中缀表达式、前缀表达式和后缀表达式在计算机中常见的表达式有三种形式：中缀表达式、前缀表达式和后缀表达式。
其中，中缀表达式是通常人们在日常生活中使用的表达式形式，如“3 + 4 * 2”。
前缀表达式是运算符位于操作数之前的形式，例如“+ 3 * 4 2”。
后缀表达式则是运算符位于操作数之后的形式，例如“3 4 2 * +”。
3. 使用栈解决表达式求值问题在解决表达式求值问题时，我们可以利用栈的特性来简化计算过程。
具体步骤如下：3.1 将中缀表达式转换为后缀表达式我们需要将中缀表达式转换为后缀表达式，这样可以简化表达式的计算顺序。
具体转换规则如下：- 从左至右扫描中缀表达式的每个数字或符号。
- 如果是操作数，则直接输出。
- 如果是运算符，则弹出栈中所有优先级大于或等于该运算符的运算符，并将其压入栈中，然后压入该运算符。
- 如果是括号，则根据括号的不同情况进行处理。
通过以上规则，我们可以将中缀表达式转换为后缀表达式。
3.2 计算后缀表达式的值得到后缀表达式后，我们可以利用栈来计算其值。
具体步骤如下：- 从左至右扫描后缀表达式的每个数字或符号。
- 如果是操作数，则压入栈中。
- 如果是运算符，则弹出栈中的两个操作数进行相应的运算，并将结果压入栈中。
- 继续扫描直到表达式结束，栈中的值即为所求结果。
通过以上步骤，我们可以使用栈来解决表达式求值问题。
4. C语言代码实现以下是使用C语言实现栈来解决表达式求值问题的代码示例：```c#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct {int top;int capacity;int* array;} Stack;Stack* createStack(int capacity) {Stack* stack = (Stack*)malloc(sizeof(Stack));stack->capacity = capacity;stack->top = -1;stack->array = (int*)malloc(stack->capacity * sizeof(int)); return stack;}int isFull(Stack* stack) {return stack->top == stack->capacity - 1; }int isEmpty(Stack* stack) {return stack->top == -1;}void push(Stack* stack, int item) {if (isFull(stack)) return;stack->array[++stack->top] = item;}int pop(Stack* stack) {if (isEmpty(stack)) return -1;return stack->array[stack->top--];}int evaluatePostfix(char* exp) {Stack* stack = createStack(strlen(exp)); for (int i = 0; exp[i]; i++) {if (isdigit(exp[i])) {push(stack, exp[i] - '0');} else {int val1 = pop(stack);int val2 = pop(stack);switch (exp[i]) {case '+':push(stack, val2 + val1); break;case '-':push(stack, val2 - val1); break;case '*':push(stack, val2 * val1); break;case '/':push(stack, val2 / val1); break;}}}return pop(stack);}int m本人n() {char exp[] = "34*2+";printf("The value of s is d\n", exp, evaluatePostfix(exp));return 0;}```以上代码实现了栈的基本功能，并利用栈来计算后缀表达式的值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<stdio.h>
#include<malloc.h>
#include<math.h>
#include<process.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100
#define STACKINCERMENT 10
typedef int Status;
typedef int OperandType;
typedef char OperatorType;
typedef struct SqStack{
int *base;
int *top;
int stacksize;
}SqStack;
char a[8][8]={
{'\0','+','-','*','/','(',')','='},
{'+','>','>','<','<','<','>','>'},
{'-','>','>','<','<','<','>','>'},
{'*','>','>','>','>','<','>','>'},
{'/','>','>','>','>','<','>','>'},
{'(','<','<','<','<','<','=','\0'},
{')','>','>','>','>','\0','>','>'},
{'=','<','<','<','<','<','\0','='}};
Status In(char c) //判断c是否运算符函数
{ if(c<48||c>57)
return TRUE;
else
return FALSE;
}//In
Status InitStack(SqStack &s) //初始化栈函数{ s.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int)); if(!s.base) exit(OVERFLOW);
s.top=s.base;
s.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStack
int GetTop(SqStack s) //取栈顶元素函数
if(s.top==s.base)
return ERROR;
e=*(s.top-1);
return e;
}//GetTop
Status Push(SqStack &s,int e) // 压栈函数
{ if(s.top-s.base>=s.stacksize){
s.base=(int *)realloc(s.base,(s.stacksize+STACKINCERMENT)*sizeof(int)); if(!s.base) exit(OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=STACKINCERMENT;
}
*s.top++=e;
return OK;
}//Push
Status Pop(SqStack &s,int &e) //出栈函数
{ if(s.top==s.base)
return ERROR;
e=*--s.top;
return OK;
}//Pop
OperatorType Precede(OperatorType c1,OperatorType c2) //判断两个运算符优先级函数
{ int i,j;
for(i=0;i<8&&a[i][0]!=c1;i++); //从第0列查找操作符c1
if(i>=8){
printf("Operator error!1\n");
exit(OVERFLOW);
}
for(j=0;j<8&&a[0][j]!=c2;j++); //从第0行查找操作符c2
if(j>=8){
printf("Operator error!2\n");
exit(OVERFLOW);
}
return a[i][j];
}//Precede
Status StackEmpty(SqStack s) //判断栈是否为空函数
{ if(s.base==s.top)
return TRUE;
return FALSE;
}//StackEmpty
OperandType Operate(OperandType a,OperatorType thera,OperandType b) //求两个元素通过指定运算的结果函数
{ switch(thera){
case'+': return a+b;
case'-': return a-b;
case'*': return a*b;
case'/': if(b==0)
{ printf("Divide zero!\n"); //除数为0,程序结束
exit(OVERFLOW);
}
else
return a/b;
default: printf("Operator error!\n"); //操作符错误,程序结束
exit(OVERFLOW);
}
}//Operate
OperandType EvaluateExpression() //求表达式值函数
{ int i,t,a,b,thera,f=0,j;
char c=0,d;
SqStack OPTR,OPND;
InitStack(OPTR); InitStack(OPND);
Push(OPTR,'=');
d=getchar();
while(c!='='||GetTop(OPTR)!='=')
{ for (i=1;In(d)==0;i=i*10) {c=c*i+d-48;d=getchar();f=1;}
if(f==1) {Push(OPND,c);c=d;f=0;}
else
{
c=d;
switch(Precede(GetTop(OPTR),c))
{
case'<': Push(OPTR,c); d=getchar();c=0;
break;
case'=': Pop(OPTR,t); d=getchar();c=0;// 消去括号
break;
case'>': Pop(OPTR,thera);
Pop(OPND,b); Pop(OPND,a);
Push(OPND,Operate(a,thera,b)); //求值并压栈 break;
case'\0': exit; break;
}
}
}
return GetTop(OPND);
}//EvaluateExpression
int main() //主函数
{
printf("%d\n",EvaluateExpression());
return 0;
}//main。