LeetCode84. 柱状图中最大的矩形[java]

1.单调栈法
维持一个单调递增栈，遍历数组中的元素，一旦发现num[i]>num[i-1]，则进栈，否则弹出 栈顶元素，进行计算，一旦发现栈顶元素对应height小于num[i]，则将i进栈。
最后到达数组末尾，对于所有栈内元素进行处理。所有栈内元素必定一个比一个小，而且还小于数组后面所有元素，所以可以用num[i]*(num.length-i)计算。

 public int largestRectangleArea(int[] heights) {
        Stack < Integer > stack = new Stack < > ();
        stack.push(-1);
        int maxarea = 0;
        for (int i = 0; i < heights.length; ++i) {
            while (stack.peek() != -1 && heights[stack.peek()] >= heights[i])
                maxarea = Math.max(maxarea, heights[stack.pop()] * (i - stack.peek() - 1));
            stack.push(i);
        }
        while (stack.peek() != -1)
            maxarea = Math.max(maxarea, heights[stack.pop()] * (heights.length - stack.peek() -1));
        return maxarea;
    }

2.动态规划法
维持2个数组，left[]和right[]。 left[0]=-1，right[height.length-1]=height。遍历数组求得左边比其大小的一个元素，right[]同样方法。最后再遍历一遍数组求最大面积

public int largestRectangleArea(int[] heights) {

        if(heights.length==0)
        {
            return 0;
        }
        int left[]=new int[heights.length];
        int right[]=new int[heights.length];
        left[0]=-1;
        right[heights.length-1]=heights.length;
        for(int i=1;i<heights.length;i++)
        {
            int point=i-1;
            while (point>=0&&heights[point]>=heights[i])
            {
                point=left[point];
            }
            left[i]=point;

        }
        for(int i=heights.length-2;i>=0;i--)
        {
            int point=i+1;
            while (point<heights.length&&heights[point]>=heights[i])
            {
             point=right[point];
            }
            right[i]=point;
        }
        int max=0;
        for(int i=0;i<heights.length;i++)
        {
            max=Math.max(max,(right[i]-left[i]-1)*heights[i]);

        }
        return  max;
    }