【链性栈】表达式求值

//表达式求值      数据结构严蔚敏 表达式求值  代码实现
#include<iostream>

using namespace std;

typedef struct _NODE_
{
    int a;
    _NODE_* pNext;
}Node,*pNode;


int Precede(int cur,int sta);        //优先级判断 函数

int EvaluateExpression();            //表达式求值 函数

int Result(int i,int Opr,int j);    //结果计算 函数
    
bool IsOper(int a);                    //运算符判读 函数


class CStack                        //标准链性栈 类
{
private:
    pNode m_pHead;
    int m_iNodeCount;


public:
    CStack()
    {
        m_pHead = NULL;
        m_iNodeCount = 0;
    }
    ~CStack()
    {
        
    }

    void InitStack();

    bool IsEmpty();

    bool PushStack(int a);

    bool PopStack(int& a);

    int GetTop();

    int GetLength();

    void DestroyStack();
};

int main()
{

    cout<<EvaluateExpression()<<endl;



    return 0;
}



void CStack::InitStack()
{
    if(!IsEmpty())
    {
        DestroyStack();
    }
    m_iNodeCount = 0;

    m_pHead = NULL;

}



bool CStack::IsEmpty()
{
    if(m_iNodeCount == 0)
    {
        return true;
    }

    return false;
}



bool CStack::PushStack(int a)
{
    pNode pNodeTemp = new Node;

    if(pNodeTemp != NULL)
    {
        pNodeTemp->a = a;
        pNodeTemp->pNext = NULL;

        if(m_pHead == NULL)
        {
            m_pHead = pNodeTemp;
        }
        else
        {
            pNodeTemp->pNext = m_pHead;

            m_pHead = pNodeTemp;
        }

        m_iNodeCount++;

        return true;
    }

    return false;
}



bool CStack::PopStack(int& a)
{
    if(IsEmpty())
    {
        return false;
    }
    pNode pNodeDel = m_pHead;

    a = m_pHead->a;

    m_pHead = pNodeDel->pNext;

    delete pNodeDel;

    pNodeDel = m_pHead;

    m_iNodeCount--;

    return true;
}

int CStack::GetTop()
{
    return m_pHead->a;
}
int CStack::GetLength()
{
    return m_iNodeCount;
}

void CStack::DestroyStack()
{
    pNode pNodeDel = m_pHead;

    while(pNodeDel != NULL)
    {
        m_pHead = pNodeDel->pNext;

        delete pNodeDel;

        pNodeDel = m_pHead;

        m_iNodeCount--;
    }
}

/***********************************/
//判断优先级函数
//先左后右
//先乘除后加减
//先括号内，再括号外
/***********************************/

//括号的优先级应该是最高的
//然后是* / > + -
//最后是遵循从左往右
//+，-，*，/的优先级均 低于 '(' ,但是均高于')';

int Precede(int cur,int sta)                    //cur 当前的运算符  sta 栈顶元素运算符
{
    char f = 0;
    switch(cur)
    {
    case '+':                                    //判断前面的运算符 （ + -优先级一样 ）
    case '-':
        {
            if(sta=='\n' || sta=='(')            //若为空 或者 （ 就压栈
            {
                f = '<';
            }
            else                                //否则，进行计算
            {
                f = '>'; 
            }

            break;
        }

    case '*':
    case '/':
        {
            if(sta=='*'||sta=='/'||sta==')')    //遇到'*' , '/' 或')' 进行计算
            {
                f = '>';
            }
            else                                //其他情况压栈
            {
                f = '<';
            }
            
            break;
        }
    case '(':
        {
            if(sta==')')                        //不可能会存在  )(  这种情况 
            {
                cout<<"Error"<<endl;

                exit(0);
            }
            else
            {
                f = '<';                        //遇到其他情况全部压栈
            }
            break;
        }
        
    case ')':
        {
            switch(sta)
            {
            case '(':
                {
                    f = '=';        
                    break;
                }
            case '\n':
                {
                    cout<<"Error."<<endl;
                    
                    exit(0);
                    break;
                }
            default:                            //遇到此情况，均进行计算
                {
                    f = '>';
                    break;
                }
            }

            break;
        }

    case '\n':                                    //'\n'一般为表达式结尾的标志了。
        {
            switch(sta)
            {
            case '\n':
                {
                    f = '=';
                    break;
                }
            case '(':
                {
                    cout<<"Error."<<endl;
                    
                    exit(0);
                }
            default:
                {
                    f = '>';
                    
                    break;
                }
            }

            break;
        }
    }

    return f;
}
int EvaluateExpression()
{

    CStack TableOper;                        //符号栈 （用来存运算符）
    CStack TableNum;                        //数组栈 （用来存数字）

    TableOper.InitStack();
    TableNum.InitStack();

    TableOper.PushStack('\n');

    char a = 0;                                //存放当前的运算符

    int i = 0;                                //存放操作数1
    int j = 0;                                //存放操作时2
    int x = 0;                                //存放TablePer栈中的栈顶元素所代表的运算符

    int PreFlag = TableOper.GetTop();
    int NowFlag = TableOper.GetTop();


    a = getchar();                            //先接受一个字符

    x = TableOper.GetTop();



    while(a!='\n' || x!= '\n')
    {



        /**********判断是否是运算符**********/
        if(IsOper(a))        
        {
            char f = Precede(a,x);                            //进行优先级判断
        
            switch(f)
            {
                case '<':                                    //如果当前运算符比栈中的运算符优先级低
                    {
                        TableOper.PushStack(a);                //那么将当前运算符a 压入栈

                        a = getchar();                        //接受下一个字符

                        NowFlag = TableOper.GetTop();        //NowFlag变为新压入栈的运算符
                    
                        break;
                    }
                case '>':                                    //如果当前运算符比栈中的运算符优先级高
                    {

                        TableOper.PopStack(x);                //将TableOper（符号栈）栈顶的 运算符 弹出栈，准备作为运算符

                        PreFlag = TableOper.GetTop();        //PreFlag为前一个运算符
                        
                        TableNum.PopStack(i);                //将TableNum（数字栈）的两个待计算的操作数 弹出栈，并分别赋给i,j;

                        TableNum.PopStack(j);

                        TableNum.PushStack(Result(i,x,j));    //    将计算完毕的结果再压栈压回TableNum中

                        break;

                    }
                case '=':                                    //如果优先级相等
                    {

                        TableOper.PopStack(x);                //TableOper中的栈顶 运算符 弹栈 给 x, 作为 待 操作的运算符
                    
                        a = getchar();                        //接受新的字符

                        break;
                    }
            }
        }

        /**********判断是否是数字**********/
        else if(a >= '0' && a <= '9')
        {
            if(PreFlag == NowFlag)                            //如果前后的符号标记相等，（即意味着一直在输入数字，如 12 + 34，这里的12 = 1*10 + 2）
            {
                if(!TableNum.IsEmpty())                        //如果当前的TableNum 数字栈 不为空
                {
                    int Temp = 0;

                    TableNum.PopStack(Temp);                //先将前一个被压入TableNum栈的数字弹出给Temp  （如弹出1）

                    Temp *= 10;                                //Temp *= 10                                  （Temp = 10）
    
                    Temp = Temp + a - 48;                    //Temp 再加上现在的a ，再进去48                  （Temp = 10 + 'a' -48 = 10 + 50 - 48 = 12）

                    TableNum.PushStack(Temp);                //再将Temp 压回到 数字栈        
    
                    a = getchar();                            //再读入字符
                }


                else                                        //反之，若为空，也就是数字栈中没有数
                {
                    TableNum.PushStack(a-48);                //直接将a-48 压入 数字栈

                    a = getchar();                            //再读入字符
                }    
            }

            else                                            //如果前后的符号标记不相等，（即意味着，输入的数字中间有间隔 运算符 如 1 + 2）
            {
                PreFlag = NowFlag;                            //把PreFlag 置为 当前的 运算符

                TableNum.PushStack(a-48);                    //直接将a-48 压入 数字栈

                a = getchar();                                //再读入字符
            
            }
        }

    /**********都不是，说明输入的表达式有误**********/
        else
        {
            cout<<"error"<<endl;

            exit(0);

        }

        x = TableOper.GetTop();
        
    }

                    
    int ans = 0;                                            //定义一个answer，作为结果返回

    TableNum.PopStack(ans);


    return ans;
}




bool IsOper(int a)                                            //判断是否是运算符，这里只是 + - * / ( ) \n
{
    switch(a)
    {
    case '+':
    case '-':
    case '*':
    case '/':
    case '(':
    case ')':
    case '\n':
        {
            return true;
        }

    default:
        {
            return false;
        }
    }
}

int Result(int i,int Opr,int j)                                //计算两个数直接的运算结果
{
    switch(Opr)
    {
    case '+':
        return i+j;
    case '-':
        return j-i;

    case '*':
        return j*i;
    case '/':
        return j/i;

    default:
        return-1;
    }

}