利用栈求表达式的值
题目：利用栈求表达式的值一．设计任务和目标编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术表达式的值。
主要功能描述如下：1、从键盘上输入表达式。
2、分析该表达式是否合法：（1）是数字，则判断该数字的合法性。
若合法，则压入数据到堆栈中。
（2）是规定的运算符，则根据规则进行处理。
在处理过程中，将计算该表达式的值。
（3）若是其它字符，则返回错误信息。
主要功能描述如下：1、从键盘上输入表达式。
2、分析该表达式是否合法：（1）是数字，则判断该数字的合法性。
若合法，则压入数据到堆栈中。
（2）是规定的运算符，则根据规则进行处理。
在处理过程中，将计算该表达式的值。
（3）若是其它字符，则返回错误信息。
程序应包括以下几个功能函数void initstack();初始化堆栈int Make_str();语法检查并计算int push_operate(int operate):将操作码压入堆栈int push_num(double num):将操作数压入堆栈int procede(int operate):处理操作码int change_opnd(int operate):将字符型操作码转换成优先级int push_opnd(int operate):将操作码压入堆栈int pop_opnd();将操作码弹出堆栈int caculate(interru_opnd):简单计算+，-，*，/double pop_num():弹出操作数程序如下：#include "stdio.h"#include "string.h"#include "stdlib.h"#define MAXLEN 100typedef struct{char op;int level;}opt;typedef struct //定义操作符栈{opt st[MAXLEN];int top;}op_stack;typedef struct //定义值栈{double D[MAXLEN];int top;}D_stack;//--------对栈操作的定义-------------opt peek(op_stack *s) //定义看栈顶函数{opt error=;if(s->top>=0)return s->st[s->top];elsereturn error;}int IsEmpty(op_stack *s) //定义判断栈空的函数{if(s->top<0)return 0;elsereturn s->st[s->top].op;}char push(op_stack *s,opt c) //定义入栈函数{s->top++;s->st[s->top]=c;return c.op;}opt pop(op_stack *s) //定义出栈函数{opt i;opt error=;if(s->top>=0){i=s->st[s->top];s->st[s->top].op='\0';s->top--;return i;}elsereturn error;}void clear(op_stack *s) //定义初始化栈{s->top=-1;}//-----------------------------define the value stack-----------------------double Dpeek(D_stack *s) //定义看栈顶函数{if(s->top>=0)return s->D[s->top];elsereturn 0;}int DIsEmpty(D_stack *s) //定义判断栈空的函数{if(s->top<0)return 0;elsereturn (int)(s->D[s->top]);}double Dpush(D_stack *s,double c) //定义入栈函数{s->top++;s->D[s->top]=c;return c;}double Dpop(D_stack *s) //定义出栈函数{double i;if(s->top>=0){i=s->D[s->top];s->D[s->top]='\0';s->top--;return i;}else return 0;}void Dclear(D_stack *s) //定义初始化栈{s->top=-1;}double calval(char *exp){op_stack os; //定义两个栈D_stack ds;char tmp[MAXLEN]=;int i=0,leng;double dtmp,dpoptmp;opt A=;opt R=;opt M=;opt D=;opt B=;opt Mo=;clear(&os);Dclear(&ds);//-----定义初始化结束-----while(*exp!='\0'){while(*exp >= '0' && *exp <= '9' || *exp == '.') {while(*exp >= '0' && *exp <= '9' || *exp == '.') {tmp[i++]=*exp++;}dtmp=atof(tmp);Dpush(&ds,dtmp);leng=strlen(tmp);for(i=0;i<leng;i++){tmp[i]='\0';}i=0;}//-------------------------------switch(*exp){case '+' :if(!IsEmpty(&os) || peek(&os).level < A.level){push(&os,A);*exp++;}else{while(IsEmpty(&os) && peek(&os).level>=A.level){switch(pop(&os).op){case '%':dpoptmp=Dpop(&ds);dpoptmp=(float)((int)Dpop(&ds)%(int)dpoptmp); Dpush(&ds,dpoptmp);break;case '*' :dpoptmp=Dpop(&ds)*Dpop(&ds);Dpush(&ds,dpoptmp);break;case '/' :dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)/dpoptmp;Dpush(&ds,dpoptmp);break;case '+':dpoptmp=Dpop(&ds)+Dpop(&ds);Dpush(&ds,dpoptmp);break;case '-':dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)-dpoptmp;Dpush(&ds,dpoptmp);break;}}push(&os,A);*exp++;}break;case '-':if(!IsEmpty(&os) || peek(&os).level < R.level){push(&os,R);*exp++;}else{while(IsEmpty(&os) && peek(&os).level>=R.level) {switch(pop(&os).op){case '%' :dpoptmp=Dpop(&ds);dpoptmp=(float)((int)Dpop(&ds)%(int)dpoptmp); Dpush(&ds,dpoptmp);break;case '*' :dpoptmp=Dpop(&ds)*Dpop(&ds);Dpush(&ds,dpoptmp);break;case '/' :dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)/dpoptmp;Dpush(&ds,dpoptmp);break;case '+':dpoptmp=Dpop(&ds)+Dpop(&ds);Dpush(&ds,dpoptmp);break;case '-':dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)-dpoptmp;Dpush(&ds,dpoptmp);break;}}push(&os,R);*exp++;}break;case '*':if(!IsEmpty(&os) || peek(&os).level < M.level){push(&os,M);*exp++;}else{while(IsEmpty(&os) && peek(&os).level>=M.level) {switch(pop(&os).op){case '%' :dpoptmp=Dpop(&ds);dpoptmp=(float)((int)Dpop(&ds)%(int)dpoptmp);Dpush(&ds,dpoptmp);break;case '*' :dpoptmp=Dpop(&ds)*Dpop(&ds);Dpush(&ds,dpoptmp);break;case '/' :dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)/dpoptmp;Dpush(&ds,dpoptmp);break;}}push(&os,M);*exp++;}break;case '/':if(!IsEmpty(&os) || peek(&os).level < D.level){push(&os,D);*exp++;}else{while(IsEmpty(&os) && peek(&os).level>=D.level) {switch(pop(&os).op){case '%' :dpoptmp=Dpop(&ds);dpoptmp=(float)((int)Dpop(&ds)%(int)dpoptmp);Dpush(&ds,dpoptmp);break;case '*' :dpoptmp=Dpop(&ds)*Dpop(&ds);Dpush(&ds,dpoptmp);break;case '/' :dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)/dpoptmp;Dpush(&ds,dpoptmp);break;}}push(&os,D);*exp++;}break;case '%':if(!IsEmpty(&os) || peek(&os).level < Mo.level){push(&os,Mo);*exp++;}else{while(IsEmpty(&os) && peek(&os).level>=Mo.level) {switch(pop(&os).op){case '%' :dpoptmp=Dpop(&ds);dpoptmp=(float)((int)Dpop(&ds)%(int)dpoptmp);Dpush(&ds,dpoptmp);break;case '*' :dpoptmp=Dpop(&ds)*Dpop(&ds);Dpush(&ds,dpoptmp);break;case '/' :dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)/dpoptmp;Dpush(&ds,dpoptmp);break;}}push(&os,Mo);*exp++;}break;case '(':push(&os,B);exp++;break;case ')':while(peek(&os).level!=-2){switch(pop(&os).op){case '%' :dpoptmp=Dpop(&ds);dpoptmp=(float)((int)Dpop(&ds)%(int)dpoptmp);Dpush(&ds,dpoptmp);break;case '*' :dpoptmp=Dpop(&ds)*Dpop(&ds);Dpush(&ds,dpoptmp);break;case '/' :dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)/dpoptmp;Dpush(&ds,dpoptmp);break;case '+':dpoptmp=Dpop(&ds)+Dpop(&ds);Dpush(&ds,dpoptmp);break;case '-':dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)-dpoptmp;Dpush(&ds,dpoptmp);break;}}pop(&os); //弹出(exp++;break;}}while(IsEmpty(&os)){switch(pop(&os).op){case '%' :dpoptmp=Dpop(&ds);dpoptmp=(float)((int)Dpop(&ds)%(int)dpoptmp);Dpush(&ds,dpoptmp);break;case '*' :dpoptmp=Dpop(&ds)*Dpop(&ds);Dpush(&ds,dpoptmp);break;case '/' :dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)/dpoptmp;Dpush(&ds,dpoptmp);break;case '+':dpoptmp=Dpop(&ds)+Dpop(&ds);Dpush(&ds,dpoptmp);break;case '-':dpoptmp=Dpop(&ds);dpoptmp=Dpop(&ds)-dpoptmp;Dpush(&ds,dpoptmp);break;.. ... .}}return Dpop(&ds);}void main(){char string[MAXLEN];char *p=string;printf("输入表达式:\n");gets(p);printf("%s=%f\n\n",string,calval(p));..v .. .。
考研计算机学科专业基础综合-25_真题-无答案
考研计算机学科专业基础综合-25(总分80,考试时间90分钟)一、单项选择题在每小题给出的四个选项中，请选出一项最符合题目要求的。
1. 设n是描述问题规模的非负整数，下面程序片段的时间复杂度是( )。
A．O(n2log2n) B．O(nlog5n) C．O(n2log5n) D．O(n3)2. 利用栈求表达式的值时，设立运算数栈OPND。
假设OPND只有两个存储单元，在下列表达式中，不发生溢出的是( )。
A．A—B*(C—D) B．(A—B)*C—DC．(A—B*C)—D D．(A—B)*(C—D)3. 已知输入序列为abcd，经过输出受限的双端队列后，能得到的输出序列是( )。
A．dacb B．cadbC．dbca D．以上答案都不对4. 一个具有1025个结点的二叉树的高度为( )。
A．11 B．10C．11至1025之间 D．10至1024之间5. 以下关于二叉排序树的说法正确的是( )。
Ⅰ在二叉排序树中，每个结点的关键字都比左孩子关键字大，比右孩子关键字小Ⅱ每个结点的关键字都比左孩子关键字大，比右孩子关键字小，这样的二叉树都是二又排序树Ⅲ在二叉排序树中，新插入的关键字总是处于最底层Ⅳ在二叉排序树中，新结点总是作为叶子结点来插入的Ⅴ二叉排序树的查找效率和二叉排序树的高度有关A．Ⅰ、Ⅱ、Ⅳ、Ⅴ B．Ⅱ、Ⅲ、Ⅳ C．Ⅰ、Ⅲ、Ⅴ D．Ⅰ、Ⅳ、Ⅴ6. 简单无向图的邻接矩阵是对称的，可以对其进行压缩存储。
若无向图G有n个结点，其邻接矩阵为A[1..n，1..n]，且压缩存储在B[1..k]，则k的值至少为( )。
A．n(n+1)/2 B．n2/2C．(n-1)(n+1)/2 D．n(n-1)/27. 若无向图G=(V，E)中含8个顶点，为保证图G在任何情况下都是连通的，则需要的边数最少是( )。
A．7 B．21 C．22 D．288. 用递归算法实现n个不同元素的有序序列的折半查找，采用一个递归工作栈时，该栈的最小容量应为( )。
基于栈的后缀算术表达式求值c语言
基于栈的后缀算术表达式求值c语言1. 引言1.1 概述本文将讨论基于栈的后缀算术表达式求值的实现过程。
后缀算术表达式（也称为逆波兰表达式）是一种无需括号即可进行运算的表达式表示方法，它将操作符置于操作数之后。
相较于传统的中缀表达式，在计算机程序中处理后缀表达式更为高效和简洁。
1.2 文章结构文章分为五个主要部分：引言、栈的概念及原理、后缀算术表达式的定义和转换、基于栈的后缀算术表达式求值算法实现以及结论与总结。
在引言部分，我们将首先介绍本文的概述和目标，对后续内容进行简要说明。
1.3 目的通过本文，我们旨在让读者了解栈数据结构的基本概念和原理，并且掌握如何利用栈来实现对后缀算术表达式进行求值的算法。
同时，我们将介绍后缀算术表达式的定义和转换方法，并给出基于栈实现该计算方式的详细步骤与示例代码。
通过深入研究并学习这些内容，读者可以加深对栈数据结构和后缀算术表达式的理解，并且能够应用所学知识解决实际问题。
本文不仅适用于计算机科学或相关专业的学生，也适合对数据结构和算法感兴趣的读者阅读和学习。
2. 栈的概念及原理2.1 栈的定义栈是一种具有特定限制条件的线性数据结构，它具备“先进后出”（Last-In-First-Out，LIFO）的特性。
栈可以看作是一个容器，其中可以存储各种类型的数据。
与实际生活中的堆栈类似，栈只允许在其末尾进行插入和删除操作。
在栈中，最后加入的元素首先被访问和处理。
这是由于栈内元素之间的相对位置关系决定的。
插入操作称为“压栈”（Push），删除操作称为“弹栈”（Pop），而从栈顶读取元素或获取栈顶元素但不删除它称为“查看”（Peek）。
2.2 栈的基本操作推入元素：将一个元素添加到栈顶。
如果已经存在满员条件，则无法执行此操作。
弹出元素：从栈顶移除一个元素，并返回移除的值。
如果没有任何元素存在，则无法执行此操作。
查看栈顶元素：获取位于栈顶处的元素值，但不对其进行删除。
判断是否为空：检查栈是否为空。
C++四则运算表达式求值算法
u 这里定义了两个构造函数，不带参数的默认 m_string 为空，带 string 类型
参数的将参数值赋予成员变量 m_string，此外还定义了赋值运算符“=”，
目 的是将一个表达式字符串 赋予 成员变量 m_string 。 因此 生 成一个 ExpressionType 的对象可以有如下两种形式： ExpressionType expr(“(2.99-4.32)*(90.8-78.66)+78.0/3.14”); 或者 ExpressionType expr; Expr = “(2.99-4.32)*(90.8-78.66)+78.0/3.14”; u DivideExpressionToItem(): 私有成员函数，返回值是一个 string 类型的 队列。其功能是将原始的中缀表达式中的操作数、操作符以及括号按顺序以 字符串的形式分解出来，然后保存在一个队列中（队列的操作规则是先进先 出）。 u ChangeToSuffix(): 私有成员函数，返回值是一个 string 类型的栈。其功 能是将队列中表示原始表达式各项的字符串调整顺序，转换成后缀表达式的 顺序，并处理掉括号，然后保存在一个栈中（栈的操作规则是先进后出）。 u IsWellForm():私有成员函数，返回 bool 值。其功能是判断原始表达式中的 括号是否匹配，如果匹配返回 true，否则返回 false。 u Size():返回原始表达式所包含的字节数。 u Calculate(): 公有成员函数，返回 double 类型的值。其功能是计算转换后 的后缀表达式的值，即原始中缀表达式的值。
abc然后分别按从左到右放入栈中如果碰到操作符就从栈中弹出两个操作数进行运算最后再将运算结果放入栈中依次进行直到表达式放入栈中然后碰到操作符则从栈中弹出的运算并将其结果d假设为放入栈中最后是操作符所以再弹出进行dc运算并将其结果再次放入栈中此时表达式结束则栈中的元素值就是该表达式最后的运算结果
利用栈来实现算术表达式求值的算法
利用栈来实现算术表达式求值的算法利用栈来实现算术表达式求值的算法算术表达式是指按照一定规则组成的运算式，包含数字、运算符和括号。
在计算机中，求解算术表达式是一项基本的数学运算任务。
根据算术表达式的性质，我们可以考虑利用栈这一数据结构来实现求值算法。
一、算法思路首先，我们需要明确一个重要概念——逆波兰表达式（ReversePolish notation）。
逆波兰表达式是一种没有括号的算术表达式，其运算规则是先计算后面的数字和运算符，再计算前面的数字和运算符。
例如，对于算术表达式“3+4*5-6”，其对应的逆波兰表达式为“3 45 * +6 -”。
那么，我们可以利用栈来实现将中缀表达式转化为逆波兰表达式的过程，具体步骤如下：1. 创建两个栈——操作数栈和操作符栈。
2. 从左到右扫描中缀表达式的每一个数字和运算符，遇到数字则压入操作数栈中，遇到运算符则进行如下操作：（1）如果操作符栈为空或当前运算符的优先级大于栈顶运算符的优先级，则将当前运算符压入操作符栈中。
（2）如果当前运算符的优先级小于或等于栈顶运算符的优先级，则将栈顶运算符弹出并加入操作数栈中，重复此过程直到遇到优先级较低的运算符或操作符栈为空为止，然后将当前运算符压入操作符栈中。
3. 扫描完中缀表达式后，若操作符栈不为空，则将其中所有运算符弹出并加入操作数栈中。
4. 最终，操作数栈中存放的就是逆波兰表达式，我们可以按照逆波兰表达式的计算规则来计算其结果。
二、算法优点利用栈来实现算术表达式求值的算法具有以下优点：1. 代码简洁易懂，易于实现和维护。
2. 由于将中缀表达式转化为逆波兰表达式后，可以减少运算符的优先级关系而消除括号，从而减少求值的复杂度，提高程序的执行效率。
三、代码实现下面是利用栈来实现算术表达式求值的算法的Python代码实现：```pythonclass Stack:def __init__(self):self.items = []def push(self, item):self.items.append(item)def pop(self):return self.items.pop()def peek(self):return self.items[-1]def is_empty(self):return len(self.items) == 0def size(self):return len(self.items)def calculate(op_num1, op_num2, operator):if operator == "+":return op_num1 + op_num2elif operator == "-":return op_num1 - op_num2elif operator == "*":return op_num1 * op_num2elif operator == "/":return op_num1 / op_num2def infix_to_postfix(infix_expr):opstack = Stack()postfix_expr = []prec = {"+": 1, "-": 1, "*": 2, "/": 2, "(": 0} token_list = infix_expr.split()for token in token_list:if token.isdigit():postfix_expr.append(token)elif token == '(':opstack.push(token)elif token == ')':top_token = opstack.pop()while top_token != '(':postfix_expr.append(top_token)top_token = opstack.pop()else:while (not opstack.is_empty()) and(prec[opstack.peek()] >= prec[token]):postfix_expr.append(opstack.pop())opstack.push(token)while not opstack.is_empty():postfix_expr.append(opstack.pop())return " ".join(postfix_expr)def postfix_eval(postfix_expr):opstack = Stack()token_list = postfix_expr.split()for token in token_list:if token.isdigit():opstack.push(int(token))else:op_num2 = opstack.pop()op_num1 = opstack.pop()result = calculate(op_num1, op_num2, token) opstack.push(result)return opstack.pop()infix_expr = "3 + 4 * 5 - 6"postfix_expr = infix_to_postfix(infix_expr)print(postfix_expr)print(postfix_eval(postfix_expr))```四、总结算术表达式求值是一项常见的数学运算任务，利用栈这一数据结构来实现求值算法是一种简单有效的方法，它将中缀表达式转化为逆波兰表达式后，可以消除括号并减少运算符的优先级关系，从而提高程序的执行效率。
栈的应用及特性
栈的应用及特性栈是计算机科学中一种非常重要的数据结构，具有广泛的应用和独特的特性。
下面将详细介绍栈的应用及特性。
一、栈的应用：1. 函数调用：在程序执行过程中，函数的调用和返回通常采用栈进行管理。
当一个函数被调用时，函数的参数和局部变量被压入栈中，函数执行完毕后，这些信息会被弹出栈恢复到调用函数的状态。
2. 表达式求值：在编程语言中，栈可用于表达式求值、中缀表达式转换为后缀表达式等相关操作。
通过利用栈的先进后出特性，可以方便地实现这些功能。
3. 递归算法：递归算法中的递归调用也可以通过栈来实现。
当算法需要递归调用时，将函数和相关变量的信息压入栈中，等到递归结束后，再从栈中弹出恢复状态。
4. 括号匹配：栈也常用于判断表达式中的括号是否匹配。
遍历表达式，遇到左括号时压入栈，遇到右括号时弹出栈顶元素，如果匹配则继续，不匹配则判定为括号不匹配。
5. 浏览器的前进后退：浏览器的前进后退功能可以使用栈实现。
每次浏览一个网页时，将该网页的URL压入栈中，点击后退按钮时，再从栈中弹出上一个URL，即可实现返回上一个网页的功能。
6. 撤销操作：在图形界面软件中，通常会有撤销操作。
使用栈可以将每一步操作的状态依次压入栈中，当用户需要撤销时，再从栈中弹出最近的状态，恢复到之前的操作状态。
二、栈的特性：1. 先进后出：栈是一种后进先出（LIFO）的数据结构，即最新添加的元素最先被访问或者删除。
这一特性使得栈能够方便地实现函数调用和返回等操作。
2. 只能操作栈顶元素：由于栈的特性，只能访问或者修改栈顶元素，无法直接访问或者修改栈中的其他元素。
需要先将栈顶元素弹出后，才能访问或者修改下一个栈顶元素。
3. 顺序存储结构：栈可以使用数组或者链表实现。
使用数组实现时，需要指定栈的最大容量，而使用链表实现时，没有容量限制。
4. 操作复杂度：栈的插入和删除操作只涉及栈顶元素，所以其操作复杂度为O(1)。
但是栈的搜索和访问操作需要从栈顶开始遍历，所以其操作复杂度为O(n)。
基于栈结构的中缀表达式求值
实验三基于栈结构的中缀表达式求值班级：计科131、问题描述从键盘输入一中缀表达式字符串，读字符串，利用栈结构实现表达式求值。
2、输入与输出输入：从键盘中缀表达式如： 32＋5×（6－4）输出：计算结果423、需求分析1.定义两个栈结构，数栈用于存放表达式中的数，符号栈用于存放表达式中的符号，实现栈的运算2.在读数的时候考虑多位运算3.实现表达式求值4、开发工具与环境硬件设备：微型计算机系统软件环境：操作系统Windows，开发工具等等5、概要设计1.结构定义typedef struct /* 运算符栈 */{ char *base,*top;int stacksize;}SqStack;typedef struct /* 运算数栈 */{ int *base,*top;int stacksize;}SqStack1;int priority[7][7]={{'>', '>', '<', '<', '<', '>', '>'}, // +{'>', '>', '<', '<', '<', '>', '>'}, // -{'>', '>', '>', '>', '<', '>', '>'}, // *{'>', '>', '>', '>', '<', '>', '>'}, // /{'<', '<', '<', '<', '<', '=', }, // ({'>', '>', '>', '>', ' ', '>', '>'}, // ){'<', '<', '<', '<', '<', ' ', '='} // #};/*用于比较符号优先级的全局二维数组*/2．各函数模块void InitStack(SqStack *s);操作结果：初始化运算符栈。
栈的应用——表达式求值
栈的应⽤——表达式求值 表达式求值是程序设计语⾔编译中的⼀个基本问题，它的实现就是对“栈”的典型应⽤。
本⽂针对表达式求值使⽤的是最简单直观的算法“算符优先法”。
本⽂给出两种⽅式来实现表达式求值，⽅式⼀直接利⽤中缀表达式求值，需要⽤到两个栈，操作数栈和操作符栈。
⾸先置操作数栈为空栈，操作符栈仅有“#”⼀个元素。
依次读⼊表达式中的每个字符，若是操作数则进操作数栈，若是操作符则和操作符栈的栈顶运算符⽐较优先权作相应操作，直⾄整个表达式求值完毕。
⽅式⼆⾸先把中缀表达式转换为后缀表达式并存储起来，然后利⽤读出的后缀表达式完成求值，其本质上是⽅式⼀的分解过程。
表达式求值的代码如下：#include <iostream>#include "stack"#include "map"using namespace std;/* 只能求⼀位整数的加减乘除混合运算 */map<char, pair<int, int>> priority; // 存放各个操作符的栈内栈外优先级,first是栈内,second是栈外char infix[50]; // 存放初始的中缀表达式char postfix[50]; // 存放转化的后缀表达式int result;void MakePriority() // 构造运算符优先级表{priority.insert(make_pair('#', make_pair(0, 0))); // isp(#)=0, icp(#)=0priority.insert(make_pair('\n', make_pair(0, 0))); // isp(\n)=0, icp(\n)=0 表达式结尾的'#'⽤'\n'代替,这样可以省略表达式末尾的结束符'#'priority.insert(make_pair('(', make_pair(1, 6))); // isp(()=1, icp(()=6priority.insert(make_pair('*', make_pair(5, 4))); // isp(*)=5, icp(*)=4priority.insert(make_pair('/', make_pair(5, 4))); // isp(/)=5, icp(/)=4priority.insert(make_pair('%', make_pair(5, 4))); // isp(%)=5, icp(%)=4priority.insert(make_pair('+', make_pair(3, 2))); // isp(+)=3, icp(+)=2priority.insert(make_pair('-', make_pair(3, 2))); // isp(-)=3, icp(-)=2priority.insert(make_pair(')', make_pair(6, 1))); // isp())=6, icp())=1}void InfixToPostfix() // 把中缀表达式转换为后缀表达式{int i = 0;stack<char> optrStack; // 操作符栈char optr; // optr为栈顶的操作符optrStack.push('#');while (!optrStack.empty()){if (isdigit(infix[i])) // 是操作数则直接输出(追加到postfix结尾){postfix[strlen(postfix)] = infix[i];postfix[strlen(postfix) + 1] = '\0';i++; // 读⼊中缀表达式的下⼀个字符}else// 是操作符, ⽐较优先级{optr = optrStack.top(); // 取出栈顶操作符if (priority[infix[i]].second > priority[optr].first) // icp(infix[i]) > isp(optr),infix[i]⼊栈{optrStack.push(infix[i]);i++;}else if (priority[infix[i]].second < priority[optr].first)// icp(infix[i]) < isp(optr),optr退栈并输出{postfix[strlen(postfix)] = optr;postfix[strlen(postfix) + 1] = '\0';optrStack.pop();}else// icp(infix[i]) = isp(optr),退栈但不输出,若退出的是'(',则继续读⼊下⼀个字符{optrStack.pop();if (optr == '(')i++;}}}}void CalculateByPostfix() // 通过后缀表达式求值{int i = 0;stack<int> opndStack; // 操作数栈int left, right; // 左右操作数int value; // 中间结果int newOpnd;while (postfix[i] != '#' && i < strlen(postfix)){switch (postfix[i]){case'+':right = opndStack.top(); // 从操作数栈中取出两个操作数opndStack.pop();left = opndStack.top();opndStack.pop();value = left + right;opndStack.push(value); // 中间结果⼊栈break;case'-':right = opndStack.top();opndStack.pop();left = opndStack.top();opndStack.pop();value = left - right;opndStack.push(value);break;case'*':right = opndStack.top();opndStack.pop();left = opndStack.top();opndStack.pop();value = left * right;opndStack.push(value);break;case'/':right = opndStack.top();opndStack.pop();left = opndStack.top();opndStack.pop();if (right == 0){cerr << "Divide by 0!" << endl;}else{value = left / right;opndStack.push(value);}break;default:newOpnd = (int)(postfix[i] - 48); // 操作数直接⼊栈opndStack.push(newOpnd);break;}i++;}result = opndStack.top();}void CalculateByInfix() // 直接利⽤中缀表达式求值{int i = 0;stack<char> optrStack; // 操作符栈stack<int> opndStack; // 操作数栈char optr; // optr为操作符栈顶的操作符int left, right, value; // 左右操作数以及中间结果optrStack.push('#');optr = optrStack.top();while (!optrStack.empty()) // 直到操作符栈为空{if (isdigit(infix[i])) // 是操作数, 进操作数栈{value = (int)(infix[i] - 48);opndStack.push(value);i++;}else// 是操作符, ⽐较优先级{optr = optrStack.top(); // 取出操作符栈顶的操作符if (priority[infix[i]].second > priority[optr].first) // icp(infix[i]) > isp(optr),infix[i]⼊栈 {optrStack.push(infix[i]);i++;}else if (priority[infix[i]].second < priority[optr].first) // icp(infix[i]) < isp(optr),optr退栈并输出{optrStack.pop();right = opndStack.top(); // 从操作数栈中取出两个操作数opndStack.pop();left = opndStack.top();opndStack.pop();switch (optr){case'+':value = left + right;opndStack.push(value); // 中间结果⼊栈break;case'-':value = left - right;opndStack.push(value); // 中间结果⼊栈break;case'*':value = left * right;opndStack.push(value); // 中间结果⼊栈break;case'/':if (right == 0){cerr << "Divide by 0!" << endl;}else{value = left / right;opndStack.push(value);}break;default:break;}}else{optrStack.pop();if (optr == '(')i++;}}}result = opndStack.top();}int main(){MakePriority(); // 构造运算符优先级表cout << "请输⼊中缀表达式：";cin >> infix;cout << "直接利⽤中缀表达式求值为：";CalculateByInfix();cout << result << endl;cout << "转化为后缀表达式：";InfixToPostfix();for (int i = 0;i < strlen(postfix);i++){cout << postfix[i];}cout << endl;cout << "利⽤后缀表达式求值为：";CalculateByPostfix();cout << result << endl;return0;} 为了⽅便起见，本⽂只是简单的设计了⼀个针对⼀位整数的四则运算进⾏求值的算法，对于处理多位整数的四则运算，需要对本⽂接受输⼊的数据类型进⾏“升阶”，把字符数组换成字符串数组，将⼀个整数的多位数字存⼊⼀个字符串进⾏处理。
栈的应用表达式求值的原理
栈的应用：表达式求值的原理一、栈的基本原理1.栈是一种具有特殊操作的线性数据结构。
2.栈的特点是后进先出（LIFO，Last In First Out）的存取方式。
3.栈有两个基本操作：入栈和出栈。
二、表达式求值的概念1.表达式是由运算符和运算对象组成的序列。
2.表达式求值是指根据运算符的优先级和结合性来计算表达式的值。
三、中缀表达式与后缀表达式1.中缀表达式：运算符位于运算对象的中间。
–例如：2 + 32.后缀表达式（逆波兰表达式）：运算符位于运算对象的后面。
–例如：2 3 +四、中缀转后缀表达式1.利用栈实现中缀表达式到后缀表达式的转换。
2.遍历中缀表达式中的每个字符，若为数字，则输出到后缀表达式中；若为运算符，则根据优先级进行处理。
3.将运算符入栈，直到出现低优先级的运算符或左括号。
4.遇到右括号时，将栈中的运算符出栈并输出，直到遇到左括号。
5.将剩余的运算符出栈并输出。
五、后缀表达式求值1.利用栈实现后缀表达式的求值。
2.遍历后缀表达式中的每个字符，若为数字，则入栈；若为运算符，则弹出栈中的两个数字进行计算，并将结果入栈。
3.最后栈中的唯一元素即为表达式的求值结果。
六、示例假设要求解的中缀表达式为：2 + 3 * 4 - 5 1. 将中缀表达式转换为后缀表达式：2 3 4 * + 5 - 2. 根据后缀表达式求值的原则，遍历后缀表达式进行计算： - 遇到数字2，入栈； - 遇到数字3，入栈； - 遇到运算符*，弹出栈中的两个数字3和2进行计算得到6，并将结果入栈； - 遇到运算符+，弹出栈中的两个数字6和4进行计算得到10，并将结果入栈； - 遇到数字5，入栈； - 遇到运算符-，弹出栈中的两个数字10和5进行计算得到5，并将结果入栈。
3. 栈中的唯一元素5即为表达式的求值结果。
七、总结1.栈的应用在表达式求值中起到关键作用。
2.利用栈可以将中缀表达式转换为后缀表达式，并通过对后缀表达式的求值获得最终结果。
数据结构强化习题课汇总
第一章绪论考点1 数据结构基础知识1.数据的逻辑结构是指（），数据的存储结构是指（）分析：数据结构包括三方面的内容：数据的逻辑结构、存储结构和数据的运算。
其中，逻辑结构是指各数据元素之间的逻辑关系，存储结构是指逻辑结构用计算机语言的实现。
解答：数据元素之间的逻辑关系；数据的逻辑结构用计算机语言的实现。
2.在数据结构中，从逻辑上可以把数据结构分为：（A）A 线性和非线性结构B 紧凑和非紧凑结构C 动态和静态结构D 内部和外部结构分析：数据结构中，逻辑上可以把数据结构分成线性结构和非线性结构。
线性结构的顺序存储结构是一种随机存取的存储结构，线性表的链式存储结构是一种顺序存储结构。
线性表若采用链式存储表示时，所有结点之间的存储单元地址可连续可不连续。
逻辑结构与数据元素本身的形式、内容、相对位置、所含结点个数无关。
关键考点点评：线性结构的特征，有且仅有一个开始结点和终端结点，所有结点最多只有一个直接前驱和后继。
栈和队列。
非线性结构的结点有多个前驱或后继，树和图。
3.数据结构在物理上可以分为（）存储结构和链式存储结构。
分析：物理存储解答：顺序4.下列术语中，（）与数据的存储结构无关A 循环队列B 堆栈C 散列表D 单链表解答： A5.（）不是算法所必须具备的特性A 有穷性B 确定性C 高效性D 可行性分析：算法的五个重要特征：有穷性、确定性、可行性、输入和输出。
解答：C考点2 时间复杂度计算1.设n是描述问题规模的非负整数，下面程序段的时间复杂度是（）2.第二章线性表考点1 线性表的基本概念1.线性表是n个（）的有限序列。
A 字符B数据元素 C 由数据项 D 信息项解析：解答 B2.线性表是一个（）。
A 有限序列，可以为空B 有限序列，不能为空C 无限序列，可以为空D 无限序列，不能为空解答 A关键考点点评：对于非空线性表1.有且仅有一个开始结点，没有直接前驱，有且仅有一个直接后继；2.有且仅有一个终结结点，没有直接后继，有且仅有一个直接前驱；3.其余的内部结点都有且仅有一个直接前驱和后继3.单链表不能随机存取元素原因是：要得到元素的存储地址，必须（）解答：从起始结点开始扫描以得到其地址注：顺序表可以，但是链表不行考点2 线性表的顺序存储结构1.下述（）是顺序存储结构的优点A 插入运算方便B 可方便地用于各种逻辑结构的存储表示C 存储密度大D 删除运算方便解答： C2.线性表的（）存储结构是随机存储结构。
四则运算表达式求值(栈+二叉树-c++版)
HUNAN UNIVERSITY 课程实习报告题目：四则运算表达式求值学生：周华毅学生学号：201308010411专业班级：计科1304 指导老师：吴帆完成日期：2015/5/1一、需求分析a)四则运算表达式求值，将四则运算表达式用中缀表达式表示，然后转换为后缀表达式，并计算结果。
b)本程序要求利用二叉树后序遍历来实现表达式的转换，同时可以使用实验2的结果来求解后缀表达式的值。
c)在字符界面上输入一个中缀表达式，回车表示结束。
如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。
d)测试数据输入：21+23*〔12-6〕输出：21 23 12 6 -*+二、概要设计抽象数据类型为实现上述程序的功能，应以字符串存储用户的输入，以及计算出的结果。
算法的基本思想根据题目要求，利用二叉树后序遍历来实现表达式的转换。
该算法的基本模块包括二叉树的建立以及如何把输入的中缀表达式利用二叉树后序遍历转化为后缀表达式。
1、首先要将输入的中缀表达式〔数字字符〕存入到二叉树中，由于存在两位或者两位以上的数，甚至还有小数，所以考虑用字符型指针存储数字字符和操作符。
2、为了便于将中缀表达式存入二叉树中，在录入中缀表达式后，要进行相应的处理，比方去掉空格符，添加结束标志，如‘=’、‘#’等。
3、中缀表达式存入到二叉树的过程中，要注意处理的顺序，如‘+’、‘-’号的优先级比‘*’、‘/’号的低，当遇到‘*’、‘/’号时，要判断树以上的节点中是否有‘+’、‘-’号，有的话要与其交换位置。
遇到‘〔’时要反复创建二叉树的结点，构建子二叉树，考虑到括号内要处理的步骤可能会较多，可以考虑用递归。
遇到‘〕’时则直接结束此子二叉树的建立。
此外二叉树中叶子结点存储操作数，非叶子结点存储操作码。
4、对创建好的二叉树进行后序遍历，即可得到相应的后缀表达式，实现方法可以用递归的方式，由于后面还要计算表达式的值，故便利的过程中要将结点中得到的数据存入新的字符数组中。