《算法与数据结构C语言描述》里的求多项达式值

在栈的应用里，作者写了将多项式值 ，但是描述的不是很清楚，露了一个说明 。

1. 从左到右读取中缀表达式,依次一个操作项.
2. 如果是操作数直接进入输出队列.
3. 读到左括号时总是将它压入栈中.
4. 读到右括号, 将最近栈顶的第一个左括号上面的操作符全部依次弹出, 送至输出队列后, 再丢弃左括号.
5. 当读到操作符时,将栈中所有优先级高于或等于当前操作符的操作符弹出，送到输出队列中.
6. 中缀表达式全部读完后，若栈中仍然有运算符，将其送到输出队列中

少了5，6的说明，但是从例子中也能看出来。一定要注意，遇到优先级高于当前处理的操作符时，栈内高于或等于此优先级的操作符逐一出栈，直到遇到小于此操作符的。

我写了多项式求值的示例代码。为了处理方便，将char** 用string[]来处理了。

栈数据结构的代码

#ifndef LINKSTACK_H
#define LINKSTACK_H

template<class T>
class Node
{
public:
    T m_Data;
    Node* m_Link;
public:
    Node(){
        m_Link = NULL;
    }
};
template<class T>
class LinkStack
{
public:
    LinkStack(){
        mTop = NULL;
    }
    ~LinkStack(){

    }
    bool isEmptyStack_link(){
        if (mTop == NULL)
        {
            return true;
        }
        return false;
    }
    bool push_link(T data){
        Node<T>* newnode = new Node<T>();
        newnode->m_Data = data;
        if(!newnode){
            return false;
        }
        newnode->m_Link = mTop;
        mTop = newnode;

        return true;
    }
    T pop_link(){
        if (!isEmptyStack_link())
        {
            T data = (mTop->m_Data);
            Node<T>* p = mTop->m_Link;
            if(mTop){
                delete mTop;
            }
            mTop = p;

            return data;
        }
    }
    T top_link(){
        if (!isEmptyStack_link())
        {
            T data = (mTop->m_Data);

            return data;
        }
    }
private:
    Node<T>* mTop;
};
#endif

多项式求值的代码

// stack.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "string.h"
#include <stdlib.h>
#include "seqstack.h"
#include "linkstack.h"
#include <string>
#include <iostream>
using namespace std;
/*
* 前缀表达式转后缀表达式 
*/
int  fixpost(char* src,string& ret,int len);
bool isOp(const char* var);                    //是否是操作符
int  result(string* des,int len);            //求后缀表达式的值（参数为已经转成后缀表达式的字符串）
int getPriority(const char* s);                //求某操作符对应的优先级
char g_op[]= {'+','-','*','/','(',')'};        //存储表达式
int  g_priority[]={1,1,2,2,3,3};            //各个表达式的优先级
int divtoken(const char* src,string* ret);    //将表达式以空格分隔
int _tmain(int argc, _TCHAR* argv[])
{
    LinkStack<int> stack;

    //     for (int i = 0 ; i < 10 ; i++)
//     {
//         stack.push_link(i);
//     }
//     for (int i = 0 ; i < 10 ; i++)
//     {
//         printf("%d\n",stack.pop_link());
//     }
    char* src = "31 * ( 5 - 22 ) + 70";
    string ret ;
    fixpost(src,ret,strlen(src));
    cout<<ret<<endl;
    string ss[10];
    int n = divtoken(ret.c_str(),ss);
    cout<<result(ss,n)<<endl;
    system("pause");
    return 0;
}
bool isOp(const char* var)
{

    if (strstr(g_op,var) == 0)
    {
        return false;
    }
    return true;
}
int divtoken(const char* src,string* ret)
{
    int len = strlen(src);
    if( src[len-1] == ''){
        len --;
    }
    int j = 0;
    for (int i = 0 ; i < len; i++)
    {
        char a = src[i];
        if(src[i] == ''){
            j++;
            continue;
        }
        ret[j] += src[i]; 
    }

    return j+1;
}
int fixpost(char* src,string& ret ,int len)
{
    if( len <= 0 ){
        return 0;
    }

    string str[30];
    int l = divtoken(src,str);

    LinkStack<string> stack;
    int j = 0;

    string temp = "";
    for (int i = 0; i < l; i++)
    {
        if (!isOp(str[i].c_str()))
        {
            ret += str[i];
            ret+="";
        }
        else{
            if (str[i] ==")")
            {
                while (!stack.isEmptyStack_link() && stack.top_link() != "(")
                {
                
                    temp = stack.pop_link();
                    if(temp!= "("){
                        ret += temp;
                        ret+="";
                    }
                
                }
                stack.pop_link();
            }
            else{
                int pri = getPriority(str[i].c_str());
                while (!stack.isEmptyStack_link() && 
                    stack.top_link() != "(" && 
                    stack.top_link() != ")" &&
                    str[i] != "("
                    )
                {
                    if ( getPriority(stack.top_link().c_str()) >= pri )
                    {
                        temp = stack.pop_link();
                            ret += temp;
                            ret+="";
                    }
                }
                stack.push_link(str[i]);
            }
        }
    }
    while (!stack.isEmptyStack_link())
    {
        ret += stack.pop_link();
        ret+="";
    }
    
    return 0;
}
int getPriority(const char* s)
{
    int index = -1;
    int i = 0;
    for (;i < sizeof(g_op)/sizeof(char);i++)
    {
        if(g_op[i] == *s){
            index = i;
            break;
        }
    }
    if(index == -1){
        return -1;
    }
    return g_priority[i];
}
int  result(string* des,int len)
{
    
    LinkStack<int> stack;
    int res = 0;
    for (int i = 0; i < len; i++)
    {
        if (isOp(des[i].c_str()))
        {
            int num1 = 0;
            int num2 = 0; 
            if (!stack.isEmptyStack_link())
            {
                num2 = stack.pop_link();
                num1 = stack.pop_link();
            }
            int res = 0;
            //如果有反射就好了
            if(des[i] == "+"){
                res = num1+num2;
            }
            if(des[i] == "-"){
                res = num1-num2;
            }
            if(des[i] == "*"){
                res = num1*num2;
            }
            if(des[i] == "/"){
                if( num2 == 0 ){res = 0;}
                else
                res = num1/num2;
            }
            stack.push_link(res);
        }
        else{
            stack.push_link(atoi(des[i].c_str()));
        }
    }
    res = stack.pop_link();
    return res;
}