后缀表达式转换为中缀表达式

yzl14 yzl14 墨衍会员 · AI 创作全网分发 墨衍智能分发 通过墨衍一键同步至各平台 可同步平台 CSDN微信公众号微博知乎掘金百家号博客园抖音小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年,写一次发全网 我也要 + 加入社区
是一道作业题,在OJ平台上提交,有效率要求。OJ平台会进行十次测试。我的第一个版本是C++写的,主要用string类型,只能通过七次,同学都说string类型可能效率不够高。第二个版本用C写,我自己在VS2015上运行没问题,但是到OJ平台上却一次也通不过。要知道前三次都是很简单情形,只要程序正确就应该没错,可能是一些内存访问操作在平台上被判为非法。求前辈们帮忙改一下,指出一下问题或者效率改进方案。在这个题上耗了两天多了。初学者。
对了有同学说C用realloc好像通不过,那不用realloc该怎么改呢?
谢谢!

题目:中缀表达式与后缀表达式

Description

将一个后缀表达式转换为一个中缀表达式。
Input Description

一个合法的后缀表达式。它由一串连续的操作数与运算符的序列构成。操作数用英文小写字母表示,且运算符只有五种,每个运算符只有一种符号表示。相邻的操作数与运算符之间均没有任何分隔符。

输入中会出现的运算符
运算符 符号 优先级 备注
阶乘 ! 高 一元运算符
乘号 * 中
除号 / 中
加号 + 低
减号 - 低
Output Description

一个中缀表达式,它由一串连续的操作数与操作符的序列构成,它与输入的后缀表达式表达同一个算术表达式。由于中缀表达式会遇到运算符的优先级问题,你需要适当地插入左括号和右括号来调整运算的优先级。输出中允许出现的运算符有七种,每个运算符只有一种符号表示。除了操作数和运算符不允许输出任何空格、换行等分隔符。

输出中允许出现的运算符
运算符 符号 优先级 备注
左括号 ( 最高
右括号 ) 最高 与左括号搭配使用
阶乘 ! 高 一元运算符
乘号 * 中
除号 / 中
加号 + 低
减号 - 低
为了减少括号的数量以及保证输出唯一性,我们要求你尽可能地避免括号的使用,除非这样做将改变表达式中某些运算的发生次序。特别要注意,左右操作数的顺序是不可改变的,我们认为 a + b 和 b + a 是不同的表达式。对于满足 结合律的运算,运算发生次序不变的情况下应该省略括号,否则不能省略括号:我们认为 (a + b) + c 与 a + b + c 是同样的表达式,而 a + (b + c) 与 a + b + c是不同的。例如: (a + b) + (c + d) 中,如果删除第一对括号,运算结果和运算次序都没有变化;如果删除第二对括号,运算结果没有变化,但是 a + b 会首先与 c 相加,导致运算次序变化。所以这种情况下应该输出 a + b + (c + d)。

Input Sample

ab+cde*f*+fd+qp-!*-+

Output Sample

a+b+(c+d*e*f-(f+d)*(q-p)!)
Hint

你可以将生成的中缀表达式转换回后缀表达式,以验证中缀表达式的正确性。 请你自行想办法验证它是否是括号最少而不影响运算次序的结果。

我的两个版本:
c++版本:
#include<iostream>
#include<string>
//#define STACK_SIZE 7000//栈的大小,可以容纳1000个表达式 使用宏定义全局变量,方便修改
//#define StringNode_SIZE 7000//StringNode 类对象中的字符串数组大小
using namespace std;
// 定义栈的数据结构。
int JudgePriority(char c);//向前引用声明 判断运算符c的优先级
int Length;//全局变量
class StringNode {//Stringnode节点,存储每一个表达式及其优先级
private:
string STring;
int priority;//优先级
public:
StringNode() {
// STring = "\0";
priority = 10;//默认初始状态
}
StringNode(char Char1) {//单个字符建立对象,只有字母是需要这种情况
STring = Char1;
priority = 4;//设定字母优先级为4,是最高,括号4与单个字母等价,阶乘3
}
StringNode(string ExpressionString, int Priority1) {//表达式字符串建立对象
// STring.at(0) = '\0';//防止栈访问出错
STring = ExpressionString;
priority = Priority1;
}
friend StringNode Compose(StringNode &SN1, char Operator, StringNode &SN2) {//由两个表达式和一个运算符组成一个新的表达式 加括号也是在这一步
AutoAddBrackets(SN1, Operator, SN2);//如果需要的话自动给SN1,2加括号
return StringNode(SN1.STring + Operator + SN2.STring, JudgePriority(Operator));
}
friend StringNode Compose(StringNode &SN1, char Operator) {//由一个表达式和一个单目运算符(!)组成一个新的表达式 加括号也是在这一步
AutoAddBrackets(SN1, Operator);//如果需要的话自动给SN1加括号
SN1.STring += Operator;
return StringNode(SN1.STring, 3);//这个运算符的优先级就给了合成的表达式(必然是阶乘的3)
}
friend void AutoAddBrackets(StringNode &SN1, char Operator, StringNode &SN2) {//使用引用!为了修改实参
if (SN1.priority >= JudgePriority(Operator) && JudgePriority(Operator) >= SN2.priority) {
SN2.AddBrackets();return;
}
else if (SN1.priority == 1 && (Operator=='*'|| Operator == '/') && SN2.priority >= 3) {
SN1.AddBrackets();return;
}
else if (SN1.priority == 1 && (Operator == '*' || Operator == '/') && SN2.priority <= 2) {
SN1.AddBrackets();SN2.AddBrackets();return;
}
else//两边都不加括号情况,最多
return;
}
friend void AutoAddBrackets(StringNode &SN1, char Operator) {
if (SN1.priority<3 ) {//如果是!
SN1.AddBrackets();
}
}
void AddBrackets() {
STring = STring.insert(0,1,'(') + ")";
priority = 4;//加括号以后,优先级变得和数字一样高
}
void PrintString() {//输出本对象中的STring字符串
cout << STring;
}
};
class Stack {
private:
StringNode *Buffer; //保存栈中的数据,指向栈首
int top; //栈的深度
public:
Stack(int Len) {
Buffer = new StringNode[Len];//这个数组只能用Buffer来指示,不能起一个数组名
top = 0;//初始没有元素,top指代第零个
}
void push(StringNode val) { //压栈操作
Buffer[top++] = val;
}
StringNode pop() { //出栈操作
top--;//由于top总是指向下一个还没有值的位置,因此先要把top后退一位
return Buffer[top];
}
void PrintStack() {//最终的输出
Buffer[0].PrintString();
}
};
bool IsCharacter(char c) {//判字母函数
return c >= 'a'&&c <= 'z';
}
bool IsBiOperator(char c) {//判二元运算符
return c == '+' || c == '*' || c == '/' || c == '-';
}
bool IsSingleOperator(char c) {//判一元运算符(!)
return c == '!';
}
int JudgePriority(char c) {//返回操作符号的优先级
if (c == '+' || c == '-')//if判断必须加括号,return可以不用
return 1;
else if (c == '*' || c == '/')
return 2;
else if (c == '!')
return 3;
else
return 10;//出错情况
}
int main()
{
int c = 0;//用于一个一个读取字符
string Str;
cin >> Str;
Length = Str.size();
Stack StackObject(Length);//建立栈对象
while (c < Str.size()) {//通过c读取一个字符
if (IsCharacter(Str.at(c))) {//如果是字母就入栈
StackObject.push(StringNode(Str.at(c)));
}
else if (IsBiOperator(Str.at(c))) {//如果是二目运算符,出栈两个节点后合成再入栈
StringNode TempSN1 = StackObject.pop();
StringNode TempSN2 = StackObject.pop();//注意出栈后的顺序
StackObject.push(Compose(TempSN2, Str.at(c), TempSN1));//2在前面
}
else if (IsSingleOperator(Str.at(c))) {//如果是一目运算符
StringNode TempSN = StackObject.pop();
StackObject.push(Compose(TempSN, Str.at(c)));
}
c++;
}
StackObject.PrintStack();
}

c版本:
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct Node {
char NodeChar;
struct Node *next;//每个节点存储一个字符和指向下一个节点的指针
};
struct HeadNode {//头结点记录表达式信息,有指向后续节点的头指针,后续节点数(字符数),以及表达式的优先级。一个头结点后面跟着一串结点链表代表一个表达式
struct Node *head;
int CharNum;
int priority;
};
void Bracket(struct HeadNode *H) {//给头结点指针H指向的头结点表示的表达式加括号
int i;
struct Node *p = (*H).head;
struct Node *q;
for (i = 0;i < ((*H).CharNum) - 1;i++) {//一直把p移动到尾节点的前一个节点(指向尾节点)
p = p->next;
}
p->next = malloc(sizeof(struct Node));//尾指针新开辟一个节点
p = p->next;//p指向这个新的尾节点
(*p).NodeChar = ')';//尾节点上的字符时右括号
p->next = NULL;//尾节点的尾指针为NULL
q = malloc(sizeof(struct Node));//用一个指向节点的指针q申请一个节点
q->next = (*H).head;
q->NodeChar = '(';
H->head = q;
(H->CharNum) += 2;
H->priority = 4;
}
void AddChar(struct HeadNode *H, char c) {
int i;
struct Node *p = (*H).head;
for (i = 0;i < (*H).CharNum - 1;i++) {//只移动到上一项,这样才能修改指针的值
p = p->next;
}
p->next = malloc(sizeof(struct Node));//这样才能真正改动Stack数组中的值
p = p->next;
p->NodeChar = c;
p->next = NULL;
(H->CharNum)++;
if (c == '+' || c == '-') {
H->priority = 1;
}
else if (c == '*' || c == '/') {
H->priority = 2;
}
else if (c == '!') {
H->priority = 3;
}
}
void Merge(struct HeadNode *H1, struct HeadNode *H2) {
int i;
struct Node *p = (*H1).head;
struct Node *q;
for (i = 0;i < (*H1).CharNum - 1;i++) {
p = p->next;
}
p->next = H2->head;
(H1->CharNum) = (H1->CharNum) + (H2->CharNum);
free(H2);
}
void DeleteHeadNode(struct HeadNode *H) {
struct Node *j = (*H).head;
struct Node *q = (*H).head;
int i = (*H).CharNum;

for (;i > 0;i--) {
q = q->next;
free(j);
j = q;
}
free(H);

}
main() {
int i;
char c;
struct HeadNode ** Stack = NULL;
int top = 0;
while (c = getchar()) {//getchar连回车都读入
if (c == '\n')
break;
if (c >= 'a'&&c <= 'z') {
struct HeadNode *H = malloc(sizeof(struct HeadNode));
if (H) {
H[0].priority = 4;
H[0].head = malloc(sizeof(struct Node));
H[0].CharNum = 1;
H[0].head->NodeChar = c;
H[0].head->next = NULL;
if (!Stack) {
Stack = malloc(sizeof(struct HeadNode *));
}
else {
Stack = realloc(Stack, sizeof(struct HeadNode *)*(top+1));
}
Stack[top] = H;
top++;
}
else {
exit(0);
}
}
else if (c == '!') {
int i;
struct Node *p = (*(Stack[top - 1])).head;
if ((*(Stack[top - 1])).priority < 3) {
Bracket(Stack[top - 1]);
}
AddChar(Stack[top - 1], '!');
}
else {
int cc;
if (c == '+' || c == '-')
cc = 1;
else if (c == '*' || c == '/')
cc = 2;
if ((*(Stack[top - 2])).priority == 1 && (*(Stack[top - 1])).priority <= 2 && cc == 2) {
Bracket(Stack[top - 2]);
Bracket(Stack[top - 1]);
AddChar(Stack[top - 2], c);
Merge(Stack[top - 2], Stack[top - 1]);
top--;
}
else if ((*(Stack[top - 2])).priority >= cc&&cc >= (*(Stack[top - 1])).priority) {
Bracket(Stack[top - 1]);
AddChar(Stack[top - 2], c);
Merge(Stack[top - 2], Stack[top - 1]);
top--;
}
else if ((*(Stack[top - 2])).priority < cc&&cc < (*(Stack[top - 1])).priority) {
Bracket(Stack[top - 2]);
AddChar(Stack[top - 2], c);
Merge(Stack[top - 2], Stack[top - 1]);
top--;
}
else {
AddChar(Stack[top - 2], c);
Merge(Stack[top - 2], Stack[top - 1]);
top--;
}
}
}
struct Node *pp = (*(Stack[0])).head;
for (i = 0;i < (*(Stack[0])).CharNum;i++, pp = pp->next) {
printf("%c", pp->NodeChar);
}
DeleteHeadNode(Stack[0]);
}
...全文

相关推荐

C语言实现中缀表达式转换为后缀表达式

主要为大家详细介绍了C语言实现中缀表达式转换为后缀表达式,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

weixin_38645862

将中缀表达式转换为后缀表达式_C++程序

将中缀表达式转换为后缀表达式_C++程序

a1005838814

中缀表达式转换为后缀表达式及逆波兰式求值

该程序实现了运算表达式转换为中缀表达式、中缀表达式转换为后缀表达式及后缀表达式求值。该程序已实现加减乘除括号运算符及求余、幂指数的求解

qq_39310287

中缀表达式转换为后缀表达式(oj题库)

中缀表达式转换为后缀表达式(oj题库) 中缀表达式转换为后缀表达式(oj题库) 题目描述 中缀表达式是一个通用的算术或逻辑公式表示方法,操作符是以中缀形式处于操作数的中间(例:3 + 4),中缀表达式是人们常用的算术表示方法。后缀表达式不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:(2 + 1) * 3 , 即2 1 + 3 *。利用栈结构,将中缀表达式转换为后缀表达式。(测试数据元素为单个字符) 输入 中缀表达式 输出 后缀表达式 代码如下 #include #include #include using namesp

weixin_38668274

c语言实现中缀表达式向后缀表达式转换

c语言实现中缀表达式向后缀表达式转换 分类:算法+数据结构

liheng0509
评论 8
收藏 已收藏
分享
返回顶部
yzl14
其它技术问题 3,880 成员 9,044 内容