算术表达式解析（第一版）

　　首先说明我算法不好，跳槽的时候发现自己的基础薄弱而且不成体系，所以这段时间（大约3个月）我将用全部可以利用的时间把常用的数据结构、算法、C++对象模型、STL、泛型编程、设计模式整理一遍，然后梳理一下思路，做到对C++基础知识体系“巨细匪遗，秩序井然”。这个目标并没有看上去那么难，可以一试。首先要攻克的是常用的数据结构和算法，这样可以结合STL容器和算法一起学习。等整理完成后就列一个表，现在暂时没有详细的计划，先列一个粗略的计划：

　　

/*　基本结构：顺序表、链表、栈、队列、哈希表、平衡二叉树、红黑树、哈夫曼树、堆、B-树、
　　结构应用：动态数组、循环队列、内存池、
　　基本算法：二分查找、快排、基数排序、堆排序、归并排序、希尔排序、
　　算法思想：回溯法、贪心法、分治法、动态规划、随机算法
　　算法应用：算术表达式解析、迷宫寻路、N皇后、
　　综合应用：脚本解释器（脚本与宿主程序交互、分支语句解析、循环语句解析、函数调用）、内存数据库（哈希索引、键值映射、增删改查、排序）*/

　　上面这些就够忙的了，如果有好的思想则继续补充。

　　用vim写了一上午，搞定了一个公式计算器，使用一个操作栈和一个数据栈，思路如下：

/*  1.格式化：对输入格式化处理为无空格字符串
　　2.有效性检查：每个字符的合法性、括号匹配、运算符前后必须有操作数
　　3.入栈扫描：字符为数字则视为有符号浮点数连续读入，然后push到数字栈；字符为操作符则判断上一个操作符的优先级，决定出栈计算或push到操作栈；
　　4.出栈计算：操作符出栈直到遇到 ( 或栈空，操作数出栈计算，结果push回栈
　　5.重复3、4直到表达式结束 */

下面是C++代码：

#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<stack>
#include<iostream>
#include<ctype.h>
using namespace std;

stack<double> nust;
stack<char> chst;
void trimspace(char*& exp)
{
    if(exp==NULL)return;
    while(isblank(*exp)) exp++;
    char* p=exp+strlen(exp)-1;
    while(isblank(*p))p--;
    *(p+1)='\0';
}

bool checkvalid(char* exp)
{
    char validchar[]={
        '(',')','+','-','*','/','%','^','.'
    };
    int unmatch=0;
    while(*exp!='\0')
    {
        bool valid=false;
        for(unsigned int i=0;i<sizeof(validchar);++i)
        {
            if(*exp==validchar[i])
            {
                valid=true;
                if(*exp=='(')
                    unmatch++;
                else if(*exp==')')
                    unmatch--;
                else if(!isdigit(*(exp+1))&&'('!=*(exp+1))
                {
                    cout<<"[8]error expression: "<<*exp<<" needs option number"<<endl;
                    return false;
                }
                break;
            }
        }
        if(!valid && !isdigit(*exp)){
            return false;
        }
        exp++;
    }
    if(unmatch!=0)
    {
        cout<<"find unmatched ()"<<endl;
        return false;
    }
    return true;
}

bool readfloat(char* p,int *diglen)
{
    *diglen=0;
    if(p==NULL)return false;
    char num[32]={0};
    int cnt=0;
    int dot=0;
    if(*p=='-'){
        p++;
        if(p&&!isdigit(*p)){
            cout<<"[5]error expression"<<endl;
            return false;
        }
        num[cnt++]='-';
    }
    while(*p!='\0')
    {
        if(isdigit(*p))
            num[cnt++]=*p;
        else if(*p=='.')
        {
            dot++;
            if(dot>1){
                cout<<"[6]error expression"<<endl;
                return false;
            }
            num[cnt++]='.';
        }
        else
        {
            break;
        }
        p++;
    }
    *diglen=cnt;
    double dval = atof(num);
    nust.push(dval);
    cout<<"push "<<dval<<endl;
    return true;
}

/*
 * ( has 0 priority
 * + - have 1 priority
 * * / have 2 priority
 * % ^ have 3 priority
 *
 */

int getlastpriority()
{
    if(chst.empty())return 0;
    char op=chst.top();
    switch(op)
    {
        case '(':
            return 0;
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
        case '%':
            return 2;
        case '^':
            return 3;
        default:
            return 0;
    }
}

bool calc()
{    
    while(!chst.empty())
    {
        char op=chst.top();
        chst.pop();
        if(op=='(') break;
        if(nust.size()<2)
        {
            cout<<"[2]expression error number stack size="<<nust.size()<<endl;
            return false;
        }
        double r=nust.top();
        nust.pop();
        double l=nust.top();
        nust.pop();
        switch(op)
        {
            case '+':
                cout<<"push "<<l+r<<endl;
                nust.push(l+r); break;
            case '-':
                cout<<"push "<<l-r<<endl;
                nust.push(l-r); break;
            case '*':
                cout<<"push "<<l*r<<endl;
                nust.push(l*r); break;
            case '/':
                cout<<"push "<<l/r<<endl;
                nust.push(l/r); break;
            case '%':
                cout<<"push "<<(int)l%(int)r<<endl;
                nust.push((int)l%(int)r); break;
            case '^':
                cout<<"push "<<pow(l,r)<<endl;
                nust.push(pow(l,r)); break;
            default:
                break;
        }
    }
    return true;
}


/*push option when last option's priority less than the current one*/
bool scan(char* exp)
{    
    int length=strlen(exp);
    for(int i=0;i<length;++i)
    {
        if(isdigit(exp[i])){
            int len;
            bool ret=readfloat(exp+i,&len);
            if(!ret){
                return false;
            }
            i+=len;
        }
        if(i>=length)
            break;
        switch(exp[i])
        {
            case '(':
                chst.push('(');
                break;
            case ')':
                calc();
                break;
            case '+':
                if(getlastpriority()>=1)
                {
                    calc();
                }
                chst.push('+');
                cout<<"push +"<<endl;
                break;
            case '-':
                if(i==0||exp[i-1]=='(')
                {
                    if(exp[i+1]=='('){
                        nust.push(0);
                        chst.push('-');
                        cout<<"push 0"<<endl;
                        cout<<"push -"<<endl;
                        break;
                    }
                    int diglen;
                    bool ret=readfloat(exp+i,&diglen);
                    if(!ret){
                        cout<<"read float falied line:"<<__LINE__<<endl;
                        return false;
                    }
                    i+=diglen-1;
                    break;
                }else{
                    if(getlastpriority()>=1)
                        calc();
                    chst.push('-');
                    cout<<"push -"<<endl;
                    break;
                }
            case '*':
                if(getlastpriority()>=2)
                    calc();
                chst.push('*');
                cout<<"push *"<<endl;
                break;
            case '/':
                if(getlastpriority()>=2)
                    calc();
                chst.push('/');
                cout<<"push /"<<endl;
                break;
            case '%':
                if(getlastpriority()>=2)
                {
                }else
                    calc();
                chst.push('%');
                cout<<"push %"<<endl;
                break;
            case '^':
                if(getlastpriority()>=3)
                    calc();
                chst.push('^');
                cout<<"push ^"<<endl;
                break;
            default:
                cout<<"[1]error expression"<<endl;
                break;
        }
    }
    return true;
}
int main(int argc,char* argv[])
{
    if(argc!=2){
        cout<<"usage:calc express"<<endl;
    }
    char* exp=argv[1];
    trimspace(exp);
    bool suc=false;
    suc=checkvalid(exp);
    if(!suc)return 1;
    suc=scan(exp);
    if(!suc){
        cout<<"scan failed"<<endl;
        return 1;
    }
    suc=calc();
    if(!suc){
        cout<<"calc failed"<<endl;
        return 1;
    }
    if(nust.size()!=1)
    {
        cout<<"[3]error expression number stack size="<<nust.size()<<endl;
        return 1;
    }
    double rst=nust.top();
    nust.pop();
    cout<<rst<<endl;
    return 0;
}

　　后来看了一下数据结构里的方法，先把中缀表达式转成后缀表达式，然后遍历表达式，将数字入栈，直接运算即可。省去了操作栈，需要一个辅助数组保存操作符，看上去数字需要用一个占位符代替。不过时间复杂度上是一样的。