中缀表达式转后缀表达式（机算）代码

代码思路取自王道数据结构

思路

初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。
从左到右处理各个元素，直到末尾。可能遇到三种情况
①遇到操作数。直接加入后缀表达式。
②遇到界限符。遇到“(”直接入機；遇到“)”则依次弹出栈内运算符并加入后缀表达式，直到
弹出“（”为止。注意：“（"”不加入后缀表达式
③遇到运算符。依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，
若碰到“（”或栈空则停止。之后再把当前运算符入栈。
按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。

流程图

按照自己得思路画了一个流程图，没有按照规范。

代码

#include <iostream>
#include <string.h>

using namespace std;

#define MaxSize 10

typedef struct{
    char data[MaxSize];//静态数组存放栈中元素
    int top;//栈顶
} SqStack;

void InitStack(SqStack &S){
    S.top = -1;//初始化栈顶指针
    memset(S.data,'0', MaxSize);
}

bool StackEmpty(SqStack S){
    if(S.top==-1)//空栈
        return true;
    else
        return false;
}

bool Push(SqStack &S,char x){
    if (S.top==MaxSize-1)
        return false;
    S.top += 1;
    S.data[S.top] = x;
    return true;
}

bool Pop(SqStack &S,char &x){
    if(S.top==-1)
        return false;
    x = S.data[S.top];
    S.top -= 1;
    return true;
}
//获取栈头
char GetHead(SqStack S){
    if(StackEmpty(S))
        return 'c';
    return S.data[S.top];
}
/**
 * 判断操作符优先级
 */
int GetPrioraty(char c){
    switch (c)
    {
        case '+':
        case '-':
            return 1;
            break;
        case '*':
        case '/':
            return 2;
            break;
        default:
            return 0;
            break;
    }
}
//比较两个字符得优先级
bool Prioraty(char c,char p){
    return GetPrioraty(c) <= GetPrioraty(p);
}
//判断字符类型
int StrType(char c){
    if(isdigit(c)){
        return 1;
    }
    if(c=='('||c==')'){
        return 2;
    }
    if(c=='+'||c=='*'||c=='-'||c=='/'){
        return 3;
    }
}

string ZzToHz(string str){
    SqStack S;
    InitStack(S);

    string zzbds;
    for (size_t i = 0; i < str.size(); i++)
    {
        char cur = str.at(i);
        int opt = StrType(cur);
        if(opt==1){//操作数直接拼接
            zzbds.push_back(cur);
            continue;
        }else if(opt==2){
            if(cur=='('){
                Push(S, cur);
                continue;
            }
            char follow;
            while(Pop(S, follow)&&follow!='('){
                zzbds.push_back(follow);
            }
        }else if(opt==3){
            char stackHead = GetHead(S);
            if(StackEmpty(S)||stackHead=='('){//取到（或取不到任何数栈为空则直接把操作符压入栈中
                Push(S, cur);
                continue;
            }

            if(Prioraty(cur,stackHead)){
                while (true)//需要弹出
                {
                    stackHead = GetHead(S);
                    if(StackEmpty(S)||stackHead=='('){
                        break;
                    }

                    if(Prioraty(cur,stackHead)){
                        zzbds.push_back(stackHead);
                        S.top--;
                    }
                }
            }
            Push(S, cur);
        }
    }

    while (!StackEmpty(S))//将栈中剩余元素拼接
    {
        char stacHead=GetHead(S);
        if(stacHead!='('){
            zzbds.push_back(stacHead);
            S.top--;
        }
    }
    return zzbds;
}

int main(int argc, char const *argv[])
{
    string zz("1+2*(3-4)-5/6");
    cout << ZzToHz(zz) << endl;
    return 0;
}