中缀转后缀

方法一

 先前的东西都给忘了，特整理一下作为笔记

/*****************************************
 * 实现表达式中缀到表达式后缀的转换
 *****************************************/

bool midtolast(string &src, string &dst)
{
    string::size_type len = src.size();
    
    /*用来保存栈中弹出的对象*/
    char temp = '\0';    
    stack<char> Mystack;
    
    for(string::size_type i = 0; i != len; ++ i)
    {
        switch(src[i])
        {
        case '(':
            {
                Mystack.push(src[i]);            
                break;
            }
            
        case ')':
            {            
                if(Mystack.empty())
                {
                    return false;
                }
                temp = Mystack.top();
                Mystack.pop();                
                while('(' != temp )
                {                    
                    dst += temp;                    
                    if(Mystack.empty())
                        break;                    
                    temp = Mystack.top();
                    Mystack.pop();
                }                
                break;
            }
            /***************************************
            乘除法操作实质上是一致的
            在压入栈中之前，需要弹出非左括号的同优先级对象
            遇到左括号或者低优先级的对象就停止，直接入栈
            ****************************************/
        case '*':
        case '/':
            {
                /*判断非空的栈，为空则直接入栈即可*/
                if(!Mystack.empty())
                {
                    temp = Mystack.top();
                    Mystack.pop();
                    while(temp != '+' && temp != '-' && temp != '(')
                    {
                        dst += temp;
                        if(Mystack.empty())
                        {
                            /*保证temp不影响后面的压栈操作*/
                            temp = '\0';
                            break;
                        }
                        temp = Mystack.top();
                        Mystack.pop();
                    }
                }
                /*如果当前的temp是+-(,则返回到栈中*/
                if(temp == '+' || temp == '-' || temp == '(')
                {
                    Mystack.push(temp);
                }
                /*将当前操作符压栈*/
                Mystack.push(src[i]);
                break;
            }
        case '-':
        case '+':
            {
                /*判断非空*/
                if(!Mystack.empty())
                {
                    /*加减操作的优先级最低，因此需要弹出所有非左括号的操作符*/
                    temp = Mystack.top();
                    Mystack.pop();
                    while(temp != '(' )
                    {
                        /*将操作符输出到后缀表达式中*/
                        dst += temp;
                        if(Mystack.empty())
                        {
                            temp = '\0';
                            break;
                        }
                        temp = Mystack.top();
                        Mystack.pop();
                    }
                }
                /*如果当前弹出的对象是’(‘,则重新压入栈中*/
                if(temp == '(')
                {
                    Mystack.push(temp);
                }
                /*将操作符本身压入栈中*/
                Mystack.push(src[i]);
                break;
            }
        default:
            {
                /*针对字符而言直接输出到后缀表达式*/
                dst += src[i];
                break;
            }
        }
    }
     /*将栈中非空的操作符输出到后缀表达式中*/
    while(!Mystack.empty())
    {
        temp = Mystack.top();
        Mystack.pop();
        dst += temp;
    }
    return true;
}

方法二

int prior(char op)//符号优先级
{
    if(op=='+'||op=='-')
        return 1;
    if(op=='*'||op=='/')
        return 2;
    return 0;
}

string middletolast(string middle)
{
    stack<char> op;
    string ans;
    for(int i=0;i<middle.size();i++)
    {
        char c=middle[i];
        if(c>='0'&&c<='9')
        {
            ans.append(1,c);
        }
        else
        {
            if(c=='(')
                op.push('(');
            else
            {
                if(c==')')
                {
                    while(op.top()!='(')
                    {
                        ans.append(1,op.top());
                        op.pop();
                    }
                    op.pop();
                }
                else
                {
                    if(op.empty())//栈为空
                    {
                        op.push(c);
                    }
                    else
                    {
                        if(prior(c)>prior(op.top()))
                            op.push(c);
                        else
                        {
                            while(!op.empty()&&prior(c)<=prior(op.top()))
                            {
                                ans.append(1,op.top());
                                op.pop();
                            }
                            op.push(c);
                        }
                    }
                }
            }
        }
    }
    while(!op.empty())
    {
        ans.append(1,op.top());
        op.pop();
    }
    return ans;
}