C语言逆波兰式算法

#include <stdio.h>

//数字模式识别 
#define IS_NUM(c)    (((c)>='0') && ((c)<='9') || ((c)=='.'))
//符号字符识别 
#define IS_OPERATOR(c) (((c)=='+') || ((c)=='-') || ((c)=='*') || ((c)=='/') || ((c)=='('))
//加减符号识别 
#define IS_AS(c) (((c)=='+') || ((c)=='-'))
//乘除符号识别 
#define IS_MD(c) (((c)=='*') || ((c)=='/'))


//逆波兰式 识别原则
//1、遇见数字直接压入输出数组里边；
//2、遇见乘除符号，则先把前边紧跟着的所有乘除符号逆序弹出到输出数组中 ，然后把当前的符号压入符号栈；
//3、遇见加减号，则把最近前括号“(”之后的的所有符号全部弹出到输出数组中，然后压入当前符号；
//4、每次遇见任何符号，都表明之前的数据识别完成，这里需要添加空格用来区分两个数据
//5、如果算式刚开始或者其他符号之后出现“-”，这这个符号会被识别成符号，
//   负数标志位置1，先在输出数组中压入0和空格，且在后边数据识别完成之后，直接添加“-”，用0-x的方式实现负数 
//6、如果遇见前括号“(” 则直接压入符号栈；如果遇见后括号“)”，则把最近的前括号之后所有的符号逆序弹出到输出数组；
//7、原式子识别完成之后，如果符号栈还有数据，则按照逆序分别弹出到输出数组中；
//缺陷：没有进行括号匹配识别，也没有处理连续两个符号重新一块输入的bug，还有一个数据输入多个小数点的bug！！！！！ 
 
//例如 1.2+-42.8/2*(1*-2.56/(3-4))*(10/5+2.6)
//a、根据原则1和原则3和原则4，输出数组：1.2（空格），符号栈：+
//b、根据原则5、1、2，输出数组 1.2 0 42.8 - 2 符号栈：+ /
//c、根据原则2，输出数组：1.2 0 42.8 - 2 /  符号栈：+ *
//d、根据原则6，输出数组：1.2 0 42.8 - 2 /  符号栈：+ * (
//e、根据原则1、2、3、4、5、6 输出数组：1.2 0 42.8 -2 /1 0 2.56 -*  符号栈：+ * (/(
//f、根据原则1、3 输出数组：1.2 0 42.8 -2 /1 0 2.56 -*3 4 -  符号栈：+ * (/(
//g、根据原则6  输出数组：1.2 0 42.8 -2 /1 0 2.56 -*3 4 -/  符号栈：+ * 
//h、之前的原则，则后续结果1.2 0 42.8 -2 /1 0 2.56 -*3 4 -/*10 5 /2.6 +*+
void RPN(char shuru[],char shuchu[]) {
    char i;    
    char scIndex     = 0;        //输出栈顶索引 
    char opera[20]    = {0};        //符号栈 
    char opIndex     = 0;        //符号栈顶索引 
    char fushu        = 0;        //负数标志位 
    char errNum        = OK;        //返回错误置 
    
    for(i=0;shuru[i]!='\0';i++) {
        if(IS_NUM(shuru[i])) {                //数据字符 
            shuchu[scIndex++] = shuru[i];    //把数组直接输出        
        } else     if(IS_MD(shuru[i])) {        //乘除字符 
            if(IS_NUM(shuchu[scIndex-1])) {    //添加空格来区分数据，如果是负数模式，则添加负号，下同 
                shuchu[scIndex++] = ' ';    //添加数据分割的空格 
                if(fushu==1) {                //负数模式 
                    shuchu[scIndex++] = '-';//把符号添加到结果中 
                    fushu=0;                //负数标志位清零 
                }
            }            
            //如果是上一个字符是乘除则一个一个弹出来填充到结果中，
            //直到符号栈没有符号，或者遇见前括号“(”    
            while(IS_MD(opera[opIndex-1]) && (opIndex>0) ) {//&& (opera[opIndex-1]!='(')
                shuchu[scIndex++] = opera[--opIndex];            
            }            
            opera[opIndex++] = shuru[i];    //填充当前符号到符号栈 
        } else if(IS_AS(shuru[i])) {        //如果是加减模式 
            if(IS_NUM(shuchu[scIndex-1])) {    //添加空格，区分负号，同上 
                shuchu[scIndex++] = ' ';
                if(fushu==1) {
                    shuchu[scIndex++] = '-';
                    fushu=0;
                }
            }    
            //如果算式刚开始就是“-”，或者其他符号紧跟着“-”则这个减号起到负数所用 
            if((shuru[i]=='-') && ((scIndex==0) || (IS_OPERATOR(shuru[i-1])))) {
                shuchu[scIndex++] = '0'; //先添加0 把负数处理成0-x的模式 
                shuchu[scIndex++] = ' ';
                fushu=1;                //负数标志位 
            } else {
                while((opIndex>0) && (opera[opIndex-1]!='(')) {//把前括号之前的符号全部弹出 
                    shuchu[scIndex++] = opera[--opIndex];            
                }    
                opera[opIndex++] = shuru[i];//压入当前符号                
            }            
            
        } else if(shuru[i]=='(') {                 //如果是前括号  则直接压入括号 
            if(IS_NUM(shuchu[scIndex-1])) {        //添加空格，区分负号，同上 
                shuchu[scIndex++] = ' ';
                if(fushu==1) {
                    shuchu[scIndex++] = '-';
                    fushu=0;
                }
            }    
            opera[opIndex++] = shuru[i];        //压入前括号 
        } else if(shuru[i]==')') {                //如果是后括号，则直接弹出前括号后边的所有符号 
            if(IS_NUM(shuchu[scIndex-1])) {
                shuchu[scIndex++] = ' ';
                if(fushu==1) {
                    shuchu[scIndex++] = '-';
                    fushu=0;
                }
            }    
            while(opera[opIndex-1]!='(') {         //弹出前括号之后的所有符号 
                shuchu[scIndex++] = opera[--opIndex];            
            }        
            opIndex--;                            //栈顶减1，剔除前括号 
        }
    }
    //puts(shuchu);    
    while((opIndex>0)) {                        //如果循环之后符号栈还有数据，则逆序弹出 
        shuchu[scIndex++] = opera[--opIndex];
    }    
}

//根据逆波兰式计算数据原则
//1、遇见数据进行数字识别，注意识别的时候有整数和小数模式，遇见空格，表明当前数据识别完成，识别完成的数据压入数据栈 ； 
//2、如果遇见符号，则按照顺序弹出两个数据，然后这两个数据按照顺序进行符号匹配的运算，结果压入数据栈； 
//3、所有数据计算完成之后，数据栈就留下唯一结果，就是最终结果 
//例如上边逆波兰式 1.2 0 42.8 -2 /1 0 2.56 -*3 4 -/*10 5 /2.6 +*+
//a、先压入1.2 0 42.8 ，当看见符号，则弹出42.8和0 ，然后计算0-42.8，把结果压入数据栈，1.2 -42.8 
//b、然后出现2，则先把2压入数据栈；
//c、遇见/，则弹出2和-42.8，计算-42.8/2结果为-21.4压入数据栈，结果为1.2 -21.4
//d、后边的数据以此类推 
float RPNOperation (char shuru[]) {        
    char i;
    float value[10]={0};    //数据和计算数据的栈 
    char vIndex=0;        //数据栈顶索引 
    char xs=0;            //小数标志位 
    float xishu=0.1;    //小数系数 
    float s0,s1;        //运算数据变量 
    
    
    for(i=0;shuru[i] != '\0';i++) {         //遍历所有逆波兰式字符串 
        if(IS_NUM(shuru[i])) {                //数字模式 
            if(shuru[i]=='.') {                //如果判断小数点，则小数标志位置1 
                xs=1;
            } else {                        //纯数字模式，则计算数据 
                if(xs==0) {                    //整数模式计算方法，a=a*10+b，其中a是上一次数据，b是当前数据 
                    value[vIndex] = value[vIndex]*10 + (shuru[i]-'0');    
                 } else if(xs==1){            //如果是小数模式，则每一个新数据都要倍一个小数系数 
                     value[vIndex] += xishu*(shuru[i]-'0');
                     xishu/=10;                //小数系数缩小到原来的十分之一，供下次使用 
                 }
            }              
        } else if(shuru[i]==' ') {            //如果是空格，则表明上边的数据已经完结 
            xs=0;                            //小数标志位清零 
            vIndex++;                         //数据栈加1 
            xishu=0.1;                        //小数系数恢复到0.1 
        } else if(IS_OPERATOR(shuru[i])) {    //如果遇见符号 
            s0=value[--vIndex];                //弹出第一数据 
            value[vIndex] = 0;                //原数据必须清零，否则，影响下一次数据识别 
            s1=value[--vIndex];                //弹出第二个数据 
            switch (shuru[i]){                //根据符号进行计算 
                case '+':value[vIndex]=s1+s0;break;
                case '-':value[vIndex]=s1-s0;break;
                case '*':value[vIndex]=s1*s0;break;
                case '/':value[vIndex]=s1/s0;break;
            }
            vIndex++;                         
            xs=0;
            xishu=0.1;
        }
    }
    return value[0];                        //运算完成之后，栈里边只留下最终结果 
}

main() {
    //带带括号嵌套，带负数的运算式 
    char shuru[]="1.2+-42.8/2*(1*-2.56/(3-4))*(10/5+2.6)";
    //逆波兰式输出数组 
    char shuchu[35]={0};
    float v;                //最终结果 
    RPN(shuru,shuchu);        //计算逆波兰式 
    puts(shuchu);            //打印逆波兰式 
    v=RPNOperation(shuchu);    //计算数据结果 
    printf("%f",v);            //打印结果 
}