Leecode_1006-笨阶层, 本来觉得这道题10分钟应该能ac，结果花了1个多小时，还是不够严谨仔细。 笨阶层 - 图1思路很简单，用栈保存每次乘除法运算的结果，碰到加减直接把操作数入栈，最后统一算。然后出栈的数字是表达式右边的数字，因为存在减法，所以我们要从前面开始算，也就是对栈做一个逆序然后先加再减。这样其实绕了一个弯，如果全是加法的话，从前往后算还是从后往前算都是一样的。所以我们碰到减法操作时入栈的时候保存负数即可。

    1. import javax.jws.soap.SOAPBinding;
    2. import java.util.*;
    4. public class Main {
    5.     public static void main(String[] args) {
    6.         System.out.println(clumsy(1));
    7.     }
    8.     public static int clumsy(int N) {
    10.         int count = 1;
    14.         Stack<Integer> operand = new Stack<>();
    15.         // 操作数
    16.         int i = N - 1;
    18.         operand.push(N);
    19.         while(i > 0) {
    20.             if(count % 4 == 1) {
    22.                 operand.push(operand.pop() * i);
    24.             }
    26.             else if(count % 4 == 2) {
    27.                 operand.push(operand.pop() / i);
    30.             }
    32.             else {
    33.                operand.push(i);
    35.             }
    36.             //else {
    37.             //  operand.push(-i);
    39.             //}
    41.             i = i - 1;
    42.             count++;
    43.         }
    44.         int m = operand.size();
    45.         int[] sum = new int[m];
    46.         //扭转栈，如果直接出栈就是从表达式后面算起，碰到减法会有问题，应该从前面开始算。
    47.         while(!operand.isEmpty()){
    48.             sum[--m] = operand.pop();
    49.         }
    51.         int result = sum[0];
    52.         int flag = 0;
    54.         for(int j = 1; j < sum.length; j++) {
    55.             System.out.println(sum[j]);
    56.             if(flag % 2 == 0)
    57.                 result = result + sum[j];
    58.             else
    59.                 result = result - sum[j];
    60.             flag++;
    61.         }
    63.         return result;
    64.     }
    65. }