Largest Rectangle in Histogram

题目：

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

For example,
Given height = [2,1,5,6,2,3],
return 10.

分析

有个精彩详细的分析

http://www.cnblogs.com/lichen782/p/leetcode_Largest_Rectangle_in_Histogram.html

代码

先附上我自己写的没有用栈的方法

时间复杂度是O（2*n^2）

public static int largestRectangleArea3(int[] height) {
        int maxArea = 0, left = 0, right = 0;
        int[] h = Arrays.copyOf(height, height.length + 1);

        for (int i = 0; i < height.length; i++) {
            int j = 1;
            while (i + j < h.length) {
                if (h[i] <= h[i + j]) {
                    j++;
                } else
                    break; // 没有break，会造成死循环。
            }
            right = i + j;
            j = 0;
            while (i - j - 1 >= 0) {
                if (h[i] <= h[i - j - 1]) {
                    j++;
                } else
                    break;
            }
            left = i - j;
            maxArea = Math.max(maxArea, h[i] * (right - left));
        }
        return maxArea;
    }

然后是时间复杂度为O（n）的方法：

package StacksAndqueues;

import java.util.Arrays;
import java.util.Stack;

public class LargestRectangleInHistogram {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] height= {2,1,5,6,2,3};
        System.out.println(largestRectangleArea(height));
    }

    // LeetCode, Largest Rectangle in Histogram
    // 时间复杂度 O(n)，空间复杂度 O(n)

    public static int largestRectangleArea(int[] height) {
        Stack<Integer> stack = new Stack<Integer>();
        int[] h = new int[height.length + 1];
        h = Arrays.copyOf(height, height.length + 1);
        int result = 0;
        int i=0;
        while(i < h.length) {  //不能用for循环，要弹栈
            if (stack.isEmpty() || h[i] >= h[stack.peek()])//stack里面只存放单调递增的索引
                stack.push(i++);
            else {
                int t = stack.pop();
                result = Math.max(result, h[t] * (stack.isEmpty() ? i : i -1- stack.peek()));
            }//栈内元素一定是要比当前i指向的元素小的。
        }
        return result;
    }
}