算术表达式的转换

算术表达式的转换

Time Limit: 1000MS Memory Limit: 65536KB

Submit Statistic Discuss

Problem Description

小明在学习了数据结构之后，突然想起了以前没有解决的算术表达式转化成后缀式的问题，今天他想解决一下。

   因为有了数据结构的基础小明很快就解出了这个问题，但是他突然想到怎么求出算术表达式的前缀式和中缀式呢？小明很困惑。聪明的你帮他解决吧。

Input

 输入一算术表达式，以\'#\'字符作为结束标志。（数据保证无空格,只有一组输入）

Output

 输出该表达式转换所得到的前缀式 中缀式 后缀式。分三行输出，顺序是前缀式 中缀式 后缀式。

Example Input

a*b+(c-d/e)*f#

Example Output

+*ab*-c/def
a*b+c-d/e*f
ab*cde/-f*+

#include <bits/stdc++.h>  
using namespace std;  
  
char str[100], string1[100];  
stack<char >S1;  //后缀运算符栈
stack<char >S2;  //前缀运算符栈 
stack<char >S3;  //总栈 
void Pre(char str[]);  
void In(char str[]);  
void Post(char str[]);  
  
int main()  
{  
    scanf("%s", str);  
    Pre(str);  
    In(str);  
    Post(str);  
    return 0;  
}  
  
void Pre(char str[])  
{  
    for(int i = strlen(str)-2; i >= 0; i--) //从右至左扫描中缀表达式 
    {  //因为字符串后面多一个#，所以是strlen(str)-2 
        char x = str[i];  
        if(x >= 'a' && x <= 'z')  //遇到操作数时，将其压入总栈S3 
        {  
            S3.push(x);  
        }  
        else  //遇到运算符时 
        {  
            if(x == ')' || S2.empty() )  //如果运算符栈S2为空或者遇到右括号 
            {  
                S2.push(x);  //直接压入S2 
            }  
            else if(x == '(')  // 遇到左括号 ，则依次弹出S2栈顶的运算符，并压入S1，直到遇到右括号 
            {  
                while(S2.top() != ')')  
                {  
                    S3.push(S2.top());  
                    S2.pop();  
                }  
                S2.pop();  //删除左括号 
            }  
            else if(x == '*' || x == '/')  //遇到*/直接压入S2 
            {  
                S2.push(x);  
            }  
            else if(x == '+' || x == '-')  //遇到+- 
            {  
                if(S2.top() == x)  //如果栈顶元素与+-优先级相同，即如果栈顶元素也是+- 
                {  
                    S2.push(x);  //压入 
                }  
                else  
                {  
                    while(!S2.empty() && S2.top() != ')')  //当S2不为空，且栈顶不为左括号 
                    {  
                        if(S2.top() == '*' || S2.top() == '/')  //栈顶为*/ 
                        {  
                            S3.push(S2.top());  // 将S2的栈顶压入总栈S3 
                            S2.pop();  //弹出栈顶 
                        }  
                        else  
                        {  
                         break;  
                        }  
                    }  
                    S2.push(x);  // 将 +-压入S2 
                }  
            }  
        }  
    }  
    while(!S2.empty()) //将S2中剩余的运算符依次弹出并 压入总栈S3 
    {  
  
        S3.push(S2.top());   
        S2.pop();  
    }  
    while(!S3.empty())  //依次弹出总栈中的元素并输出 
    {  
        cout << S3.top();  
        S3.pop();  
    }  
    cout << endl;  
}  
  
  
  
void In(char str[])  //中缀表达式仅需要去掉括号 
{  
    for(int i = 0; str[i] != '#'; i++)  
    {  
        if(str[i] != '(' && str[i] != ')')  
        {  
            cout << str[i];  
        }  
    }  
    cout << endl;  
}  
  
void Post(char str[])  //后缀表达式 
{  
    for(int i = 0; str[i] != '#'; i++)  //从左至右扫描中缀表达式 
    {  
        char x = str[i];  
        if(x >= 'a' && x <= 'z')  //遇到操作数直接输出 
        {  
            cout << x;  
        }  
        else  //遇到运算符 
        {  
            if(x == '(' || S1.empty())  //如果遇到左括号或者S1为空 
            {  
                S1.push(x);  //直接压入S1 
            }  
            else if(x == ')')  //遇到右括号 
            {  
                while(S1.top() != '(')  //依次弹出S1栈顶的运算符并直接输出 
                {  //直到遇到左括号为止 
                    cout << S1.top();  
                    S1.pop();  
                }  
                S1.pop();  //此时将这一对括号丢弃 
            }  
            else if(x == '+' || x == '-')  //遇到+- 
            {  
                while(!S1.empty() && S1.top() != '(')  //S1不为空且栈顶不是左括号 
                {  
                    cout << S1.top();  //弹出栈顶并输出 
                    S1.pop();  
                }  
                S1.push(x);  //+-压入S1 
            }  
            else if(x == '*' || x == '/')  //遇到*/ 
            {  
                while(!S1.empty() && S1.top() != '(')  //S1不为空且栈顶不是左括号 
                {  
                    if(S1.top() == '*' || S1.top() == '/')  //如果与栈顶优先级相同 
                    {  
                        cout << S1.top();  //弹出并输出栈顶 
                        S1.pop();  
                    }  
                    else  
                    {  
                        break;  
                    }  
                }  
                S1.push(x);  //再将运算符压入S1 
            }  
        }  
    }  
    while(!S1.empty())  //输出S1剩余的运算符 
    {  
        cout << S1.top();  
        S1.pop();  
    }  
    cout << endl;  
}  
将中缀表达式转换为前缀表达式：
遵循以下步骤：
(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
(2) 从右至左扫描中缀表达式；
(3) 遇到操作数时，将其压入S2；
(4) 遇到运算符时，比较其与S1栈顶运算符的优先级：
(4-1) 如果S1为空，或栈顶运算符为右括号“)”，则直接将此运算符入栈；
(4-2) 否则，若优先级比栈顶运算符的较高或相等，也将运算符压入S1；
(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较；
(5) 遇到括号时：
(5-1) 如果是右括号“)”，则直接压入S1；
(5-2) 如果是左括号“(”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到右括号为止，此时将这一对括号丢弃；
(6) 重复步骤(2)至(5)，直到表达式的最左边；
(7) 将S1中剩余的运算符依次弹出并压入S2；
(8) 依次弹出S2中的元素并输出，结果即为中缀表达式对应的前缀表达式。
例如，将中缀表达式“1+((2+3)×4)-5”转换为前缀表达式的过程如下：

  
  
   
   
扫描到的元素
S2(栈底->栈顶)
S1 (栈底->栈顶)
说明
5
5
空
数字，直接入栈
-
5
-
S1为空，运算符直接入栈
)
5
- )
右括号直接入栈
4
5 4
- )
数字直接入栈
×
5 4
- ) ×
S1栈顶是右括号，直接入栈
)
5 4
- ) × )
右括号直接入栈
3
5 4 3
- ) × )
数字
+
5 4 3
- ) × ) +
S1栈顶是右括号，直接入栈
2
5 4 3 2
- ) × ) +
数字
(
5 4 3 2 +
- ) ×
左括号，弹出运算符直至遇到右括号
(
5 4 3 2 + ×
-
同上
+
5 4 3 2 + ×
- +
优先级与-相同，入栈
1
5 4 3 2 + × 1
- +
数字
到达最左端
5 4 3 2 + × 1 + -
空
S1中剩余的运算符
  
  因此结果为“- + 1 × + 2 3 4 5”。

将中缀表达式转换为后缀表达式：
与转换为前缀表达式相似，遵循以下步骤：
(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
(2) 从左至右扫描中缀表达式；
(3) 遇到操作数时，将其压入S2；
(4) 遇到运算符时，比较其与S1栈顶运算符的优先级：
(4-1) 如果S1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
(4-2) 否则，若优先级比栈顶运算符的高，也将运算符压入S1（注意转换为前缀表达式时是优先级较高或相同，而这里则不包括相同的情况）；
(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较；
(5) 遇到括号时：
(5-1) 如果是左括号“(”，则直接压入S1；
(5-2) 如果是右括号“)”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃；
(6) 重复步骤(2)至(5)，直到表达式的最右边；
(7) 将S1中剩余的运算符依次弹出并压入S2；
(8) 依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式（转换为前缀表达式时不用逆序）。

例如，将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下：
  
  
   
   
扫描到的元素
S2(栈底->栈顶)
S1 (栈底->栈顶)
说明
1
1
空
数字，直接入栈
+
1
+
S1为空，运算符直接入栈
(
1
+ (
左括号，直接入栈
(
1
+ ( (
同上
2
1 2
+ ( (
数字
+
1 2
+ ( ( +
S1栈顶为左括号，运算符直接入栈
3
1 2 3
+ ( ( +
数字
)
1 2 3 +
+ (
右括号，弹出运算符直至遇到左括号
×
1 2 3 +
+ ( ×
S1栈顶为左括号，运算符直接入栈
4
1 2 3 + 4
+ ( ×
数字
)
1 2 3 + 4 ×
+
右括号，弹出运算符直至遇到左括号
-
1 2 3 + 4 × +
-
-与+优先级相同，因此弹出+，再压入-
5
1 2 3 + 4 × + 5
-
数字
到达最右端
1 2 3 + 4 × + 5 -
空
S1中剩余的运算符