利用栈求表达式的值
数据结构-表达式求值
数据结构：线性结构—栈实现表达式求值一．问题分析利用栈这种数据结构存储数字和运算符，并实现表达式求值。
为实现按运算符优先顺序进行计算，需要在执行程序的过程中对运算符的优先顺序做出判断。
利用栈先进后出的特点，同时保证优先级最高的运算符始终在栈顶。
当栈顶元素优先级低于读入的运算符时，将该栈顶运算符推出。
这就保证了优先级高的运算符先计算。
二．数据结构—栈1.优先关系表：prior[7][7]={// +-*/()#'>','>','<','<','<','>','>','>','>','<','<','<','>','>','>','>','>','>','<','>','>','>','>','>','>','<','>','>','<','<','<','<','<','=',' ','>','>','<','>',' ','>','>','<','<','<','<','<',' ','='};将关系表直接用字符型的二维数组存储。
计算机408统考真题
计算机专业基础综合考试模拟试卷（一）一、单项选择题：第1～40小题，每小题2分，共80分。
下列每题给出的四个选项中，只有一个选项最符合试题要求。
1．已知一个栈的进栈序列是1、2、3、…、n，其输出序列为p1、p2、p3、…、p n，若p1=3，则p2为（）。
A．2或4、5、…、n都有可能B．可能是1C．一定是2 D．只可能是2或4 2．利用栈求表达式的值时，设立运算数栈OPEN。
假设OPEN只有两个存储单元，则在下列表达式中，不会发生溢出的是（）。
A．A−B*(C−D) B．(A−B)*C−D C．(A−B*C)−DD．(A−B)*(C−D)3．已知A[1…N]是一棵顺序存储的完全二叉树，9号结点和11号结点共同的祖先是（）。
A．4 B．6 C．2D．84．在常用的描述二叉排序树的存储结构中，关键字值最大的结点是（）。
A．左指针一定为空B．右指针一定为空C．左、右指针均为空D．左、右指针均不为空5．分别以下列序列构造二叉排序树，与用其他三个序列所构造的结果不同的是（）。
A．（100,80, 90,60,120,110,130）B．（100,120,110,130,80,60,90）C．（100,60,80,90,120,110,130）D．（100,80, 60,90,120,130,110）6．设无向图G=(V,E)和G′=(V′,E′)，如果G′是G的生成树，则下面说法错误的是（）。
A．G′是G的子图B．G′是G的连通分量C．G′是G的极小连通子图且V=V′D．G′是G的一个无环子图7．若G是一个具有36条边的非连通无向简单图，则图G的结点数至少是（）。
A．11 B．10 C．9D．88．在有向图G的拓扑序列中，若顶点V i在顶点V j之前，则下列情形不可能出现的是（）。
A．G中有弧<V i，V j> B．G中有一条从V i到V j的路径C．G中没有弧< V i，V j> D．G中有一条从V j到V i的路径9．具有12个关键字的有序表中，对每个关键字的查找概率相同，折半查找查找成功和查找失败的平均查找长度依次为（）。
基于栈的后缀算术表达式求值c语言
基于栈的后缀算术表达式求值c语言1. 引言1.1 概述本文将讨论基于栈的后缀算术表达式求值的实现过程。
后缀算术表达式（也称为逆波兰表达式）是一种无需括号即可进行运算的表达式表示方法，它将操作符置于操作数之后。
相较于传统的中缀表达式，在计算机程序中处理后缀表达式更为高效和简洁。
1.2 文章结构文章分为五个主要部分：引言、栈的概念及原理、后缀算术表达式的定义和转换、基于栈的后缀算术表达式求值算法实现以及结论与总结。
在引言部分，我们将首先介绍本文的概述和目标，对后续内容进行简要说明。
1.3 目的通过本文，我们旨在让读者了解栈数据结构的基本概念和原理，并且掌握如何利用栈来实现对后缀算术表达式进行求值的算法。
同时，我们将介绍后缀算术表达式的定义和转换方法，并给出基于栈实现该计算方式的详细步骤与示例代码。
通过深入研究并学习这些内容，读者可以加深对栈数据结构和后缀算术表达式的理解，并且能够应用所学知识解决实际问题。
本文不仅适用于计算机科学或相关专业的学生，也适合对数据结构和算法感兴趣的读者阅读和学习。
2. 栈的概念及原理2.1 栈的定义栈是一种具有特定限制条件的线性数据结构，它具备“先进后出”（Last-In-First-Out，LIFO）的特性。
栈可以看作是一个容器，其中可以存储各种类型的数据。
与实际生活中的堆栈类似，栈只允许在其末尾进行插入和删除操作。
在栈中，最后加入的元素首先被访问和处理。
这是由于栈内元素之间的相对位置关系决定的。
插入操作称为“压栈”（Push），删除操作称为“弹栈”（Pop），而从栈顶读取元素或获取栈顶元素但不删除它称为“查看”（Peek）。
2.2 栈的基本操作推入元素：将一个元素添加到栈顶。
如果已经存在满员条件，则无法执行此操作。
弹出元素：从栈顶移除一个元素，并返回移除的值。
如果没有任何元素存在，则无法执行此操作。
查看栈顶元素：获取位于栈顶处的元素值，但不对其进行删除。
判断是否为空：检查栈是否为空。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程，通过本次实验，旨在加深对常见数据结构（如链表、栈、队列、树、图等）的理解和应用，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
操作系统为 Windows 10。
三、实验内容1、链表的实现与操作创建一个单向链表，并实现插入、删除和遍历节点的功能。
对链表进行排序，如冒泡排序或插入排序。
2、栈和队列的应用用栈实现表达式求值，能够处理加、减、乘、除和括号。
利用队列实现银行排队系统的模拟，包括顾客的到达、服务和离开。
3、二叉树的遍历与操作构建一棵二叉树，并实现前序、中序和后序遍历。
进行二叉树的插入、删除节点操作。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历。
四、实验步骤及结果1、链表的实现与操作首先，定义了链表节点的结构体：｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀插入节点的函数：｀｀｀cppvoid insertNode(ListNode& head, int val) ｛ListNode newNode ＝ new ListNode(val)；head ＝ newNode;｝ else ｛ListNode curr ＝ head;while （curr>next!＝ NULL) ｛curr ＝ curr>next;｝curr>next ＝ newNode;｝｝｀｀｀删除节点的函数：｀｀｀cppvoid deleteNode(ListNode& head, int val) ｛if （head ＝＝ NULL) ｛return;｝ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL ＆＆ curr>next>data!＝ val) ｛curr ＝ curr>next;｝if （curr>next!＝ NULL) ｛ListNode temp ＝ curr>next;curr>next ＝ curr>next>next;delete temp;｝｝｀｀｀遍历链表的函数：｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛std:：cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝std:：cout ＜＜ std:：endl;｝｀｀｀对链表进行冒泡排序的函数：｀｀｀cppvoid bubbleSortList(ListNode& head) ｛if （head ＝＝ NULL ｜｜ head>next ＝＝ NULL) ｛return;｝bool swapped;ListNode ptr1;ListNode lptr ＝ NULL;do ｛swapped ＝ false;ptr1 ＝ head;while （ptr1-＞next!＝ lptr) ｛if （ptr1-＞data ＞ ptr1-＞next>data) ｛int temp ＝ ptr1-＞data;ptr1-＞data ＝ ptr1-＞next>data;ptr1-＞next>data ＝ temp;swapped ＝ true;｝ptr1 ＝ ptr1-＞next;｝lptr ＝ ptr1;｝ while （swapped)；｝｀｀｀测试结果：创建了一个包含 5、3、8、1、4 的链表，经过排序后，输出为 1 3 4 5 8 。
利用栈来实现算术表达式求值的算法
利用栈来实现算术表达式求值的算法利用栈来实现算术表达式求值的算法算术表达式是指按照一定规则组成的运算式，包含数字、运算符和括号。
在计算机中，求解算术表达式是一项基本的数学运算任务。
根据算术表达式的性质，我们可以考虑利用栈这一数据结构来实现求值算法。
一、算法思路首先，我们需要明确一个重要概念——逆波兰表达式（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 * 2 / (1 - 5)”的逆波兰表达式为“3 4 2 * 1 5 - / +”。
逆波兰表达式求值时，可以使用栈来存储数字和运算符，具体过程如下：1. 遍历逆波兰表达式中的每个元素。
2. 如果当前元素是数字，则压入栈中。
3. 如果当前元素是运算符，则从栈中弹出两个操作数进行运算，并将结果压入栈中。
4. 遍历完逆波兰表达式后，栈顶即为表达式的值。
以下是Python语言实现逆波兰表达式求值的代码：def evalRPN(tokens: List[str]) -> int:stack = []for token in tokens:if token in '+-*/': # 运算符num2 = stack.pop()num1 = stack.pop()if token == '+':stack.append(num1 + num2)elif token == '-':stack.append(num1 - num2)elif token == '*':stack.append(num1 * num2)else:stack.append(int(num1 / num2))else: # 数字stack.append(int(token))return stack[0]该函数接受一个字符串列表tokens，其中包含了逆波兰表达式的所有元素。
基于栈结构的中缀表达式求值
实验三基于栈结构的中缀表达式求值班级：计科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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构课程设计姓名：杨颂敬班级：软件0901班学号：0930*******目录：1．需求分析 (1)2．概要设计 (1)3．详细设计................................. 3-6 4．调试分析................................. 6-8 5．用户使用说明 (8)6．测试结果 (9)7．附录 (9)利用栈求表达式的值，可供小学生作业，并能给出分数。
1．需求分析任务：通过此系统可以实现如下功能：此系统能够输入一个表达式，并计算该表达式的值。
可以根据计算结果给出分数。
能供小学生进行简单的四则运算，此外这里特别强调括号的匹配！要求：根据以上功能说明，设计运算信息，堆栈的存储结构，设计程序完成功能；2. 概要设计在此说明每个部分的算法设计说明（可以是描述算法的流程图），每个程序中使用的存储结构设计说明（如果指定存储结构请写出该存储结构的定义）。
主菜单3．详细设计#include "string.h"#include "stdio.h"#include"conio.h"#define maxsize 100#include "ctype.h"typedef char datatype;typedef struct{datatype stack[maxsize];int top;} seqstack;void stackinitiate(seqstack *s){s->top=0;}int stacknotempty(seqstack s){if(s.top<=0) return 0;else return 1;}int stackpush(seqstack *s, datatype x) {if(s->top>=maxsize){printf("堆栈已满无法插入!\n");return 0;}else{s->stack[s->top]=x;s->top++;return 1;}}int stackpop(seqstack *s,datatype *d) {if(s->top<=0){printf("堆栈已空无数据元素出栈!\n");return 0;}else{s->top--;*d=s->stack[s->top];return 1;}}int stacktop(seqstack s,datatype *d){if(s.top<=0){printf("堆栈已空!\n");return 0;}else{*d=s.stack[s.top-1];return 1;}}void expiscorrect(char exp[], int n){seqstack mystack;int i;char c;stackinitiate(&mystack);for(i=0;i<n;i++){if(exp[i]=='(')stackpush(&mystack, exp[i]);else if((exp[i]==')') && stacknotempty(mystack) && stacktop(mystack,&c) && c=='(') stackpop(&mystack,&c);else if((exp[i]==')') && !stacknotempty(mystack)){printf("右括号多余左括号!\n");return ;}}if(stacknotempty(mystack))printf("左括号多余右括号!\n");elseprintf("左右括号匹配正确!\n");}static float ans[50];static int count=0;static int right=0;static float yourresult[50];int postexp(char exp[]){seqstack mystack;datatype x1,x2;int i;int j=0,ls;int top=0;int isFalse=0;int isRead=0;char oprator = ' ';stackinitiate(&mystack);for(i=0;exp[i]!='#';i++){if(isdigit(exp[i])){top=(int)(exp[i]-48);top*=10;}else{if (isRead == 0){isRead++;top/=10;stackpush(&mystack,top);oprator = exp[i];top=0;}else if (isRead == 1){stackpush(&mystack,top);if (isRead == 1){isRead++;stackpop(&mystack,&x2);}stackpop(&mystack,&x1);ls=x1;x1=x2;x2=ls;x1/=10;switch(oprator){case '+': {x1+=x2;break;}case '-': {x1-=x2;break;}case '*': {x1*=x2;break;}case '/':{if(x2==0.0){printf("除数为0错!\n");isFalse=1;}else{x1/=x2;}};break;}oprator = exp[i];x2=x1;top=0;}}}if (isRead == 0){isRead++;top/=10;stackpush(&mystack,top);oprator = exp[i];top=0;}else if (isRead == 1){stackpush(&mystack,top);if (isRead == 1){isRead++;stackpop(&mystack,&x2);}stackpop(&mystack,&x1);ls=x1;x1=x2;x2=ls;x1/=10;switch(oprator){case '+': {x1+=x2;break;}case '-': {x1-=x2;break;}case '*': {x1*=x2;break;}case '/':{if(x2==0.0){printf("除数为0错!\n");isFalse=1;}else{x1/=x2;}};break;}oprator = exp[i];x2=x1;top=0;}if (isFalse == 1) return -1;ans[count] = x1;printf("请输入您计算的结果：");scanf("%f",&yourresult[count]);if(ans[count]==yourresult[count]) right++;count++;getchar();}int main(){int i=0;char exp[100];printf(" ------计算表达式------\n使用说明：\n");printf(" 1.请输入要计算的表达式，以#结尾，例如1+2#\n");printf(" 2.结束计算请输入符号$\n");printf(" 3.在表达式中可以运算括号，中括号[]和大括号{}统一使用小括号代替()!\n");printf(" 4.程序输入格式错误时，将会自动结束程序，请注意格式正确！\n");printf("请输入要计算的表达式，以#结尾。
结束程序输入$。
\n");// c=getchar();scanf("%s",exp);while(exp[i]!='$'){expiscorrect(&exp,i);postexp(&exp);printf("-------------------------------------------\n");printf("请输入下一个表达式，以#结尾。
结束程序输入$。
\n");scanf("%s",exp);// c=getchar();}printf("\n\n ******您的成绩单*******\n");printf("----------------------------------------\n");printf(" 序号正确答案您的答案结论\n");for(i=0;i<count;i++){printf("表达式%d %.2f %.2f %s\n",i+1,ans[i],yourresult[i],ans[i]==yourresult[i]?"正确！":"错误！");}printf("----------------------------------------\n");printf("解答题目总共为%d道，其中\n",count);printf("正确解答%d道题，错误解答%d道题。
\n *****最后得分为%d分！*****\n", right,count-right,right*100/count);printf("----------------------------------------\n");getchar();getchar();return 0;}4．调试分析5．用户使用说明运行程序，然后根据提示进行计算并给出分数，然后退出。