逻辑计算

题目描述：

常用的逻辑计算有And（表示为&）；Or（表示为|）；Not（表示为！）。其中，他们的优先级关系是Not（！）>And（&）>Or（|）。

输入描述：

1、测试用例中间无空格，无需考虑空格。

2、测试用例表达式只会出现如下字符：“0”，“1”，“（”，“）”，“&”，“|”，“！”。

3、测试用例所给的输入都是合法输入，无需要考虑非法输入。

4、测试用例长度不会超过128个字符。

5、括号可以重复嵌套。

例如：

1 | ( 1 & 0 )                       返回值：1

1 & 0 | 0 & 1                     返回值：0

! 0 & 1 | 0                          返回值：1

( ( ! 0 & 1 ) ) | 0                 返回值：1

输出描述：

输出逻辑运算后的最终结果：0或者1

示例1：
输入：! ( 1 & 0 ) | 0 & 1

输出：1

示例2：
输入：! ( 1 & 0 ) & 0 | 0

输出：0

按照中缀表达式求值的思路去做

  @Test
    public void logic(){
        String line="((!0&1))|0";
        Stack stack=new Stack(); //保存数字
        Stack op=new Stack(); //保存操作符
        for(int i=0;i<line.length();i++){
            char c=line.charAt(i);
            switch (c){
                case '(':
                    op.push(c);
                    break;
                case ')':
                    char top=(char)op.peek();
                    while(top!='('){
                        if(top=='!') {
                            int a=Integer.valueOf(stack.pop()+"");
                            if(a==1) stack.push(0);
                            else stack.push(1);
                        }
                        else{
                            int a=Integer.valueOf(stack.pop()+"");
                            int b=Integer.valueOf(stack.pop()+"");
                            if(top=='&') stack.push(a&b);
                            else if(top=='|') stack.push(a|b);
                        }
                        op.pop();
                        if(!op.isEmpty()) top=(char)op.peek();
                    }
                    op.pop(); //弹出左括号
                    break;
                case '!':
                    op.push(c);
                    break;
                case '&':
                    if(!op.isEmpty()){
                        char top2=(char)op.peek();
                        while(top2=='!'){
                            int a=Integer.valueOf(stack.pop()+"");
                            if(a==1) stack.push(0);
                            else stack.push(1);
                            op.pop(); //弹出 ‘！’
                            if(!op.empty()) top2=(char)op.peek();
                            else break;
                        }
                    }
                    op.push(c);
                    break;
                case '|':
                    if(!op.isEmpty()){
                        char top3=(char)op.peek();
                        while(top3=='!'||top3=='&'){
                            if(top3=='!'){
                                int a=Integer.valueOf(stack.pop()+"");
                                if(a==1) stack.push(0);
                                else stack.push(1);
                            }
                            else{
                                int a=Integer.valueOf(stack.pop()+"");
                                int b=Integer.valueOf(stack.pop()+"");
                                stack.push(a&b);  //1 & 0 | 0 & 1
                            }
                            op.pop(); //弹出 ‘！’ 或者‘&’
                            if(!op.empty()) top3=(char)op.peek();
                            else break;
                        }
                    }
                    op.push(c);
                    break;
                default:  //数字，直接入栈
                    stack.push(c);
                    break;
            }
        }

        while(!op.isEmpty()){
            char top=(char)op.pop();
            if(top=='!'){
                int number=Integer.valueOf(stack.pop()+"");
                if(number==1) stack.push(0);
                else stack.push(1);
                continue;
            }
            int a=Integer.valueOf(stack.pop()+"");
            int b=Integer.valueOf(stack.pop()+"");
            if(top=='&') stack.push(a&b);
            else if(top=='|') stack.push(a|b);
        }
        System.out.println(stack.pop());
    }