RPN-逆波兰计算器-中缀表达式转后缀表达式-javascript

1、利用栈（Stack）来存储操作数和操作符；
　2、包含中缀表达式转后缀表达式的函数，这个是难点，也是关键点；
　　2.1、将输入字符串转为数组；
　　2.2、对转换来的字符进行遍历；创建一个数组，用来给存储转换为后缀表达式的字符；创建一个栈，用来存储操作符；
　　2.3、通过正则来过滤，为数字的则放在数组中，其他的则放在栈中；
　　2.4、接下来是最麻烦的操作符判断，我做的这个比较简单，如果再复杂些，我这个可能还要进行扩展或优化；
　　2.5、对操作符的判断按照其优先级来，首先是括号，有‘（’，直接压人，等到有‘）’的时候再一个个的将括号内的操作符进行弹出，如果里面有两个以上，则要先弹
　　　　　　靠近‘（’的；
　　2.6、然后是乘除。这里，我将乘除的弹栈放在了它的入栈前面，两则并不冲突，也不会对其他操作符有影响，因为它在添加数字的时候，就把乘或除弹出来了添加到数组；
　　2.7、上一个乘或除已经被弹出去了，数字添加后，如果后面字符是乘或除，则就直接入栈。（比如测试testing中的第一字符串，有连个两个乘）；
　　2,8、最后是加减。首先，如果是空栈，直接入栈，如果不是空栈，则判断栈顶是否有‘（’，有则直接入栈，如果栈顶这些情况都没有（前面已经经乘除考虑了，这里就无需考虑了），
　　　　　　则说明栈内都是加或减，这时可以
将栈顶元素弹栈，并添加到数组中，再将当前操作符入栈。
　3、包含后缀表达式的计算方式；
　4、利用主函数main来调用；
　5、cmd测试。

 function Stack(){
     this.store = [];
     this.top = 0;
     this.push = push;
     this.pop = pop;
 }

 function push(ele){
     this.store[this.top++] = ele;
 }

 function pop(){
     var top = --this.top;
     if(top >= 0){
         var val =  this.store[top];
 //-----------------务必删除弹出栈的值原来的空间----------------------------
         this.store.splice(this.top,1);
         return val;
     }else{
         return 'It\' Ending !';
     }

 }
 //----------------中缀表达式转后缀表达式-----------------------------------
 function normalChar(normalC){
     normalC = normalC.split(' ');
     var arr = [];
     var ls = new Stack();
     var reg = /\d/;

     for(var i=0; i<normalC.length; i++){
         if(reg.test(normalC[i])){
             arr.push(normalC[i]);

         }
         if(normalC[i] == '('){
             ls.push(normalC[i]);
         }
         else if(normalC[i] == ')'){
             while(ls.store[ls.top-1] != '('){
                 arr.push(ls.pop());
             }
             ls.pop();
         }
 //-----------------此处是在添加数字的时候进行的，不会和其他操作符发生冲突--
         else if(ls.store[ls.top-1] == '*' || ls.store[ls.top-1] =='/'){
             arr.push(ls.pop());
         }

         else if(normalC[i] == '*' || normalC[i] =='/'){
             ls.push(normalC[i]);

         }
         else if(normalC[i] == '+' || normalC[i] =='-'){
             if(ls.top == 0){
                 ls.push(normalC[i]);
             }
             else if(ls.top > 0){
                 if(ls.store[ls.top-1] == '('){
                     ls.push(normalC[i]);
                 }else{
                     arr.push(ls.pop());
                     ls.push(normalC[i]);
                 }
             }

         }

     }
     while(ls.store != 0){
         arr.push(ls.pop());
     }
     return arr;
     console.log(arr);
 }

 //------------------------Testing---------------------------------------
 function main(){
     //输入时做提示，以空格间隔每个操作符和操作数
 //var normalC = ' 1 - ( 2 + 3 ) * 4 * 2 + 10 / 5 ';
 var normalC = '2 + 3 * 4 * ( 3 - 2 )';
 var stack = new Stack();
 var char = normalChar(normalC);
 var p = 0,s = 0;
 var reg = /\d/;
 for(var i=0; i<char.length; i++){
     if(reg.test(char[i])){
         stack.push(char[i]);
     }else{
         switch(char[i]){
             case '-':
                 p = stack.pop();
                 s = stack.pop();
                 stack.push(Number(s)-Number(p));
                 break;
             case '+':
                 p = stack.pop();
                 s = stack.pop();
                 stack.push(Number(s)+Number(p));
                 break;
             case '*':
                 p = stack.pop();
                 s = stack.pop();
                 stack.push(Number(s)*Number(p));
                 break;
             case '/':
                 p = stack.pop();
                 s = stack.pop();
                 if(p != 0){
                     stack.push(Number(s)/Number(p));
                 }else{
                     console.log("除数不能为0");
                     break;
                 }
         }
     }
 }
 console.log(stack.store);
 }
 main();