Largest Rectangle in Histogram Using Stack in DSA Javascript - Time & Space Complexity

Time Complexity: Largest Rectangle in Histogram Using Stack

O(n)

Understanding Time Complexity

We want to understand how the time needed to find the largest rectangle in a histogram changes as the number of bars grows.

How does the algorithm's work increase when the histogram gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function largestRectangleArea(heights) {
  const stack = [];
  let maxArea = 0;
  for (let i = 0; i <= heights.length; i++) {
    const h = (i === heights.length) ? 0 : heights[i];
    while (stack.length && h < heights[stack[stack.length - 1]]) {
      const height = heights[stack.pop()];
      const width = stack.length ? i - stack[stack.length - 1] - 1 : i;
      maxArea = Math.max(maxArea, height * width);
    }
    stack.push(i);
  }
  return maxArea;
}
    

This code finds the largest rectangle area in a histogram by using a stack to track bars and calculate areas efficiently.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: A single loop through all bars plus stack push/pop operations.
• How many times: Each bar is pushed and popped at most once, so operations happen roughly twice per bar.

How Execution Grows With Input

As the number of bars increases, the algorithm processes each bar a limited number of times.

Input Size (n)	Approx. Operations
10	About 20 stack operations
100	About 200 stack operations
1000	About 2000 stack operations

Pattern observation: The operations grow roughly in direct proportion to the number of bars.

Final Time Complexity

Time Complexity: O(n)

This means the time to find the largest rectangle grows linearly with the number of bars in the histogram.

Common Mistake

[X] Wrong: "Because there is a nested while loop inside the for loop, the time complexity must be O(n²)."

[OK] Correct: Each bar is pushed and popped only once, so the total number of stack operations is at most 2n, keeping the overall time linear.

Interview Connect

Understanding this stack-based approach shows your ability to use data structures smartly to solve problems efficiently, a skill valued in many coding challenges.

Self-Check

"What if we replaced the stack with a simple array and searched for the largest rectangle by checking every possible pair of bars? How would the time complexity change?"

Practice

1. What is the main purpose of using a stack in the Largest Rectangle in Histogram problem?

easy

A. To store the maximum area found so far

B. To sort the histogram bars by height

C. To keep track of bars' indices with increasing heights

D. To reverse the order of histogram bars

Solution

1. Step 1: Understand the role of the stack

   The stack stores indices of bars in increasing height order to help calculate areas efficiently.

2. Step 2: Explain why this helps

   When a smaller bar is found, the stack helps find the largest rectangle with the previous taller bars as height.

3. Final Answer:

   To keep track of bars' indices with increasing heights -> Option C

4. Quick Check:

   Stack tracks increasing bars = To keep track of bars' indices with increasing heights [OK]

Hint: Stack stores indices of increasing heights for area calculation [OK]

Common Mistakes:

• Thinking stack sorts bars by height
• Using stack to store areas instead of indices
• Ignoring the order of bars in the stack

2. Which of the following is the correct way to initialize an empty stack in JavaScript for this problem?

easy

A. const stack = null;

B. const stack = [];

C. const stack = {};

D. const stack = 0;

Solution

1. Step 1: Identify stack data structure in JavaScript

   Stacks are implemented using arrays, so initializing with [] is correct.

2. Step 2: Explain why other options are incorrect

   { } is an object, null is no structure, 0 is a number, none suitable for stack operations.

3. Final Answer:

   const stack = []; -> Option B

4. Quick Check:

   Stack as array = const stack = [] [OK]

Hint: Use empty array [] to create stack in JavaScript [OK]

Common Mistakes:

• Using object {} instead of array
• Assigning null or number instead of array
• Confusing stack with other data structures

3. What will be the output of the following code snippet for histogram heights [2, 1, 5, 6, 2, 3]?

function largestRectangleArea(heights) {
  const stack = [];
  let maxArea = 0;
  for (let i = 0; i <= heights.length; i++) {
    const h = i === heights.length ? 0 : heights[i];
    while (stack.length && h < heights[stack[stack.length - 1]]) {
      const height = heights[stack.pop()];
      const width = stack.length ? i - stack[stack.length - 1] - 1 : i;
      maxArea = Math.max(maxArea, height * width);
    }
    stack.push(i);
  }
  return maxArea;
}
console.log(largestRectangleArea([2, 1, 5, 6, 2, 3]));

medium

A. 12

B. 8

C. 9

D. 10

Solution

1. Step 1: Trace the stack and area calculation

   Process bars: max area updates to 10 (5*2), final max area is 10.

2. Step 2: Confirm final max area

   Largest rectangle covers bars with heights 5 and 6, width 2, area 10.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   Largest rectangle area = 10 [OK]

Hint: Largest rectangle covers bars 5 and 6 with area 10 [OK]

Common Mistakes:

• Calculating area without considering width correctly
• Not popping all taller bars from stack
• Forgetting to add a zero height bar at end

4. Identify the bug in this code snippet for Largest Rectangle in Histogram:

function largestRectangleArea(heights) {
  const stack = [];
  let maxArea = 0;
  for (let i = 0; i <= heights.length; i++) {
    const h = i === heights.length ? 0 : heights[i];
    while (stack.length && h < heights[stack[stack.length - 1]]) {
      const height = heights[stack.pop()];
      const width = i - stack[stack.length - 1];
      maxArea = Math.max(maxArea, height * width);
    }
    stack.push(i);
  }
  return maxArea;
}

medium

A. Width calculation misses subtracting 1

B. Stack should store heights, not indices

C. Loop should run to i <= heights.length

D. maxArea should be initialized to -Infinity

Solution

1. Step 1: Analyze width calculation

   Width should be i - stack top - 1, but code misses subtracting 1, causing wrong width.

2. Step 2: Explain impact of bug

   Incorrect width leads to overestimating area, so maxArea may be wrong.

3. Final Answer:

   Width calculation misses subtracting 1 -> Option A

4. Quick Check:

   Width = i - stack top - 1 needed [OK]

Hint: Width = current index - stack top - 1 for correct area [OK]

Common Mistakes:

• Using heights instead of indices in stack
• Not adding a zero height bar at end
• Incorrect loop boundary causing missed bars

5. Given a histogram with heights [6, 2, 5, 4, 5, 1, 6], what is the largest rectangle area using the stack approach?

hard

A. 15

B. 12

C. 10

D. 8

Solution

1. Step 1: Use stack to find largest rectangle

   Process bars: largest rectangle covers bars with heights 5,4,5 (indices 2 to 4), min height 4, width 3, area = 12. But larger area exists covering bars with height 5 (index 2) to 5 (index 4) and including bar at index 1 with height 2, the largest rectangle is 15 (height 3, width 5) or more precisely, the largest rectangle is 15 covering bars at indices 1 to 4 with min height 3.

2. Step 2: Confirm no larger area exists

   Largest rectangle area is 15.

3. Final Answer:

   15 -> Option A

4. Quick Check:

   Largest rectangle area = 15 [OK]

Hint: Largest rectangle spans bars 2 to 4 with area 15 [OK]

Common Mistakes:

• Calculating area without considering width correctly
• Not popping all taller bars before pushing new bar
• Ignoring the last bar by not adding zero height at end