中缀转后缀表达式计算

一、中缀表达式转后缀表达式遵循以下原则：

1.遇到操作数，直接输出； 
2.栈为空时，遇到运算符，入栈； 
3.遇到左括号，将其入栈； 
4.遇到右括号，执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出； 
5.遇到其他运算符’+”-”*”/’时，弹出所有优先级大于或等于该运算符的栈顶元素，然后将该运算符入栈； 
6.最终将栈中的元素依次出栈，输出。 
经过上面的步骤，得到的输出既是转换得到的后缀表达式。 
举例：a+b*c+(d*e+f)g ———> abc+de*f+g*+

 

二、.扫描后缀表达式： 
①如果是数字，则让其进栈 
②若为操作符，则从栈中取出两个操作数，先取出的作为右操作数，后取出的作为左操作数，然后进行该操作符的运算，并使其结果入栈。 
③重复上述过程，直至表达式扫描完成。 
   最终栈中只留一个元素—–>即就是结果。 

 

#include
#include
#include  
#include
using namespace std;

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

        if (isdigit(str[0]))//中缀表达式的第一个必定是数字，如果不是，则非法
        {
            break; 
        }
        else
        {
            cout << "INPUT ERROR ！！！";
            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 s;
    s.push('#');
    while (*middle)
    {
        if (isdigit(*middle) || *middle == '.')   //如果是数字或者小数的话，直接输出
        {
            *back = *middle;
            back++, middle++;
        }
        else
        {
            if (isdigit(*(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 << "后缀表达式是: " << 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 s;
    while (*back)
    {
        if (isdigit(*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 << "表达式值为: " < }

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