Largest rectangle in a histogram

Problem: Given an array of bar-heights in a histogram, find the rectangle with largest area.

Solution: Assuming, all elements in the array are positive non-zero elements, a quick solution is to look for the minimum element h_min in the array.
Then numElements * h_min can be one of the possible candidates for the largest area rectangle.

If that is not the largest rectangle, then the solution for the largest rectangle will not contain h_min bar.

For any bar in the histogram, bounds of the largest rectangle enclosing it are those bars which are smaller than the current bar. This means that the largest rectangle enclosing any bar will have bars greater than or equal to that bar. Hence whenever we see two consecutive bars such that l_k < l_k-1, we know that the rectangle for l_k-1 must end there itself.
So any l_k < l_k-1 property tells us the right bound for rectangle of l_k-1.

Exploiting this property, following algorithm can be used:

1. Loop over the input array and maintain a stack of increasing bar lengths. This can be called an Increasing Stack
2. If current element is greater than stack-top, push it to stack top.
3. If current element is smaller than stack-top, then start removing elements from stack till it has elements greater than the current.
   For each popped element, find largest histogram area using:
   1. Right boundary as current element or current element – 1 (as explained above)
   2. Left boundary as next stack-top element or 0 (Because our stack stores only increasing length of bars, it implies that all bars absent between two consecutive bars in the stack must be longer than both of them)
   3. If all elements of the stack have been popped, this means that all bars before the current bar were longer and so their rectangles ended here. To begin afresh for the others, current bar is put into the stack.
4. If any elements are left in stack after the above loop, then pop them one by one and repeat #3

Sample execution

Consider barHeights = [10, 40, 30, 70, 10, 30, 60]

As per the above algorithm, ‘stk’ and ‘maxArea’ will vary as follows:

1. Consider 10
   stk = [0]
   maxArea = 0
2. Consider 40
   stk = [0, 1]
   maxArea = 0
3. Consider 30
   Pop elements from the stack till a minimum one is found.
   So, 40 is popped. Its right-boundary is 1 and left boundary is 0, so max-area is 40
   stk = [0, 2]
   maxArea = 40
4. Consider 70
   stk = [0, 2, 3]
   maxArea = 40
5. Consider 10
   Elements are popped from the stack in the inner loop.
   stk = [0, 2]
   rightBoundary for 70 = 3
   leftBoundary for 70 = 2
   maxArea = max (40,70) = 70

   stk = [0]
   rightBoundary for 30 = 3
   leftBoundary for 30 = 0
   maxArea = max(70, 90) = 90

   stk = []
   rightBoundary for 10 = 4
   leftBoundary for 10 = 0
   maxArea = max(90, 40) = 90

   stk = [4]

6. Consider 30
   stk = [4,5]
   maxArea = 90
7. Consider 60
   stk = [4,5, 6]
   maxArea = 90
8. Now, elements are popped from the stack one by one.
   Right boundary for all of them is 6

   stk = [4,5]
   maxArea = max (90, 60) = 90

   stk = [4]
   maxArea = max (90, 30) = 90

   stk = []
   maxArea = max (90, 80) = 90