后缀表达式

后缀表达式：9 3 1-3*+ 10 2/+

• 规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。

下面是详细的步骤：

1. 初始化一个空栈。此桟用来对要运算的数字进出使用。

2. 后缀表达式中前三个都是数字，所以9、3、1进栈。

3. 接下来是减号“-”，所以将栈中的1出栈作为减数，3出栈作为被减数，并运算3-1得到2，再将2进栈。

4. 接着是数字3进栈。

5. 后面是乘法“*”，也就意味着栈中3和2出栈，2与3相乘，得到6，并将6进栈。

6. 下面是加法“+”，所以找中6和9出找，9与6相加，得到15，将15进栈。

7. 接着是10与2两数字进栈。

8. 接下来是符号因此，栈顶的2与10出栈，10与2相除，得到5，将5进栈。

9. 最后一个是符号“+”，所以15与5出找并相加，得到20，将20进栈。

10. 结果是20出栈，栈变为空。

 后缀表达式又称逆波兰表达式，明显的特点是：逆波兰表达式中没有括号，计算时将操作符之前的第一个数作为右操作数，第二个数作为左操作数，进行计算，得到的值继续放入逆波兰表达式中。 
　　 但日常生活中我们总是习惯于写中缀表达式，所以需要先将中缀表达式转为后缀表达式。 
　　 假如中缀表达式为：12*（3+4）-6+8/2 
　　 在遇到数字时，我们直接输出，遇到符号，则入栈。但在入栈时，我们要判断栈内已有的操作符的优先级和需要判断的操作符的优先级的大小。 
　　 栈内<栈外：入栈操作符 
　　 栈内>栈外：出栈操作符 
　　 栈内=栈外：出栈 栈内的操作符并入栈 栈外的操作， 
　　 遇到 ‘（’：直接入栈 
　　 遇到 ‘）’：出栈所有操作符直达遇到 ‘（’ 
　　 因为第一个操作符进入时也需要比较，所以在创建出保存操作符的栈时，直接就入栈一个’#’，别的字符也行，只要是非操作符就行，并将其优先级设为”1”，其他操作设为更低的”-1”。 
　　 优先级： 
　　 0–>’#’; 
　　 1–>’(‘; 
　　 2–>’+’; 
　　 2–>’-‘; 
　　 3–>’*’; 
　　 3–>’/’; 
　　 4–>’)’； 
　　 其他情况下优先级均为’-1’。但是我们在判断优先级时，因为’(‘的优先级为’1’，比较小，所以判断时要先判断是否为’(‘，是的话直接入栈，我们可以用if，else if，else完成。 
　　 具体代码实现如下： 
　　

#include <iostream>
#include <stack>
#include <math.h>
using namespace std;

bool Number(char ch)//判断是否为数字，是则返回true
{
    if (ch >= 48 && ch <= 57)
        return true;
    else
        return false;
}

void InPut(char*& str)//接收输入的中缀表达式的函数，并简单判断是否合法
{
    cout << "Please Enter What You Want To calculation:" << endl;
    while (1)
    {
        cin >> str;

        if (Number(str[0]))//中缀表达式的第一个必定是数字，如果不是，则非法
        {
            break; 
        }
        else
        {
            cout << "Illegal Input,Please Input Again:";
            delete[] str;
        }
    }
}

int GetPriority(char sy)//设置各个操作符的优先级
{
    switch (sy)
    {
    case '#':
        return 0;
    case '(':
        return 1;
    case '+':
    case '-':
        return 3;
    case '*':
    case '/':
        return 5;
    case ')':
        return 6;
    default:
        return -1;
    }
}


void AddSpace(char*& arr)//给转成的后缀表达式的数字和符号添加空格，区分每个字符
{
    *arr = ' ';
    arr++;
}

char* GetBack()//获取后缀表达式的函数
{
    char* middle = new char[30];
    char* back = new char[30];
    char* backend = back;
    InPut(middle);
    stack<char> s;
    s.push('#');
    while (*middle)
    {
        if (Number(*middle) || *middle == '.')//如果是数字或者小数的话，直接输出
        {
            *back = *middle;
            back++, middle++;
        }
        else
        {
            if (Number(*(back - 1)))//只有他的上一个时数字的话，才继续给空格
                                    //否则遇到多个操作符，则输出域会存在多个空格
            {
                //*back = ' ';
                //back++;
                AddSpace(back);
            }
            if (*middle == ')')//如果右括号的话，输出所有操作符直到遇到左括号，并抛弃相对应的一堆括号
            {
                while (s.top() != '(')
                {
                    *back = s.top();
                    s.pop();
                    back++;
                    AddSpace(back);
                }
                middle++;
                s.pop();//抛弃左括号
            }
            else if (*middle == '(')//遇到左括号，则进入栈
            {
                s.push(*middle); middle++;
            }
            else if (GetPriority(*middle) > GetPriority(s.top()))//如果栈内的操作符优先级高于栈外的优先级，则入栈
            {
                s.push(*middle); middle++;
            }
            else if (GetPriority(*middle) <= GetPriority(s.top()))
                                                     //如果栈内的操作符优先级低于或等于栈外的优先级，输出栈内的符号，并入栈栈外的符号
            {
                *back = s.top();
                s.pop(); 
                s.push(*middle);
                back++; middle++;
                AddSpace(back);
            }
        }
    }
    while (s.top() != '#')//中缀表达式遍历完成，但是=栈中还有符号存在，一一出栈输出
    {
        AddSpace(back);
        *back = s.top();
        s.pop(); back++;
    }
    *back = '\0';
    cout << "The Back Is: " << backend << endl;
    return backend;
}

double GetNumber(char*& arr)
{
    //因为输出为char*，所以可能两位数以上的数字被拆开，此函数为正确得到数字
    double sum[10] = { 0 }; int i = 0; double result = 0;
    while (*arr != ' ')
    {
        sum[i] = *arr-48;
        i++;
        arr++;
    }
    int k = i - 1;
    for (int j = 0; j < i; j++,k--)
    {
        result += (sum[j] * pow(10, k));
    }
    return result;
}

double Cauculate(char ch, double left, double right)//各个操作符对应的操作
{
    switch (ch)
    {
    case '+':
        return left + right;
    case '-':
        return left - right;
    case '*':
        return left * right;
    case '/':
        return left / right;
    default:
        return 0;
        break;
    }
}

double CountBack(char* back)
{
    stack<double> s;
    while (*back)
    {
        if (Number(*back))//遇到数字
        {
            s.push(GetNumber(back));//将正确的数字入栈
        }
        else if (*back == ' ')
        {
            back++;//遇到空格跳过
        }
        else
        {
            double a = s.top();
            s.pop();
            double b = s.top();
            s.pop();
            s.push(Cauculate(*back, b, a));//遇到符号时，取栈顶的第二个数和第一个数求解，并入栈
            back++;
        }
    }
    while (s.size() >= 2)//最终栈内存在的数大于2时，继续计算，直到只剩下一个数
    {
        double a = s.top();
        s.pop();
        double b = s.top();
        s.pop();
        s.push(Cauculate(*back, b, a));
    }
    //返回这个数字，既是最终结果
    return s.top();
}

void FunTest()
{
    cout << "The Result Is: " <<CountBack(GetBack()) << endl;
}

int main()
{
    FunTest();
    system("pause");
    return 0;
}