Trapping Rain Water Using Stack in DSA C# - Build from Scratch

Trapping Rain Water Using Stack

📖 Scenario: Imagine you have a row of walls of different heights. When it rains, water gets trapped between these walls. We want to find out how much water is trapped.

🎯 Goal: Build a program that uses a stack to calculate the total amount of trapped rain water between walls represented by their heights.

📋 What You'll Learn

Create an integer array called heights with the exact values: 0,1,0,2,1,0,1,3,2,1,2,1

Create an empty stack of integers called stack

Use a while loop with an index i to traverse heights

Inside the loop, use stack.Peek() and stack.Pop() to calculate trapped water

Calculate and store the total trapped water in an integer variable called waterTrapped

Print the value of waterTrapped at the end

💡 Why This Matters

🌍 Real World

Calculating trapped rain water helps in designing drainage systems and understanding water flow in terrains.

💼 Career

This problem is common in coding interviews and helps develop skills in using stacks and solving array problems.

1

Create the heights array

Create an integer array called heights with these exact values: 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1

DSA C#

# Create the heights array
# Your code here

Hint

Use int[] heights = { ... }; with the exact numbers inside the braces.

2

Create the stack and initialize variables

Create an empty stack of integers called stack and an integer variable waterTrapped set to 0. Also create an integer i set to 0 to use as an index.

DSA C#

int[] heights = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
# Create stack, waterTrapped, and i variables
# Your code here

Hint

Use Stack<int> stack = new Stack<int>(); and initialize waterTrapped and i to zero.

3

Implement the main loop to calculate trapped water

Use a while loop with the condition i < heights.Length. Inside the loop, use stack.Count, stack.Peek(), and stack.Pop() to calculate trapped water. Update waterTrapped accordingly and push i onto stack. Increment i by 1 at the end of each loop.

DSA C#

int[] heights = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
Stack stack = new Stack();
int waterTrapped = 0;
int i = 0;

# Add the while loop and core logic here
# Your code here

Hint

Use nested while loops. Pop from stack when current height is greater than height at top of stack. Calculate trapped water using distance and bounded height.

4

Print the total trapped water

Print the value of waterTrapped using Console.WriteLine.

DSA C#

int[] heights = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
Stack stack = new Stack();
int waterTrapped = 0;
int i = 0;

while (i  0 && heights[i] > heights[stack.Peek()])
    {
        int top = stack.Pop();
        if (stack.Count == 0)
            break;
        int distance = i - stack.Peek() - 1;
        int boundedHeight = Math.Min(heights[i], heights[stack.Peek()]) - heights[top];
        waterTrapped += distance * boundedHeight;
    }
    stack.Push(i);
    i++;
}

# Print the total trapped water
# Your code here

Hint

Use Console.WriteLine(waterTrapped); to show the result.

Practice

1. What is the main purpose of using a stack in the Trapping Rain Water Using Stack algorithm?

easy

A. To keep track of bars that are not yet processed for water trapping

B. To store the total amount of trapped water

C. To sort the height array in ascending order

D. To reverse the height array for easier calculation

Solution

1. Step 1: Understand the role of the stack

   The stack stores indices of bars that are waiting for a right boundary to trap water.

2. Step 2: Explain why other options are incorrect

   The stack does not store water amount, sort, or reverse the array; it helps find boundaries.

3. Final Answer:

   To keep track of bars that are not yet processed for water trapping -> Option A

4. Quick Check:

   Stack tracks bars for trapping water = A [OK]

Hint: Stack holds indices of bars waiting for right boundary [OK]

Common Mistakes:

• Thinking stack stores water amount directly
• Assuming stack sorts or reverses the array
• Confusing stack with a queue

2. Which of the following C# code snippets correctly declares a stack to be used for trapping rain water heights?

easy

A. List<int> stack = new List<int>();

B. Stack<int> stack = new Stack<int>();

C. Stack stack = new Stack();

D. Queue<int> stack = new Queue<int>();

Solution

1. Step 1: Identify correct stack declaration

   Stack<int> stack = new Stack<int>(); uses generic Stack<int> which is type-safe and correct for storing indices.

2. Step 2: Explain why others are incorrect

   Stack stack = new Stack(); is non-generic and less type-safe; C uses List, not stack; D uses Queue, wrong data structure.

3. Final Answer:

   Stack<int> stack = new Stack<int>(); -> Option B

4. Quick Check:

   Generic Stack<int> is correct stack declaration [OK]

Hint: Use generic Stack<int> for indices in C# [OK]

Common Mistakes:

• Using non-generic Stack without type safety
• Using List instead of Stack
• Confusing Queue with Stack

3. What is the output of the following C# code snippet that uses stack to calculate trapped rain water?

int[] height = {0,1,0,2,1,0,1,3,2,1,2,1};
int water = 0;
Stack<int> stack = new Stack<int>();
for (int i = 0; i < height.Length; i++) {
    while (stack.Count > 0 && height[i] > height[stack.Peek()]) {
        int top = stack.Pop();
        if (stack.Count == 0) break;
        int distance = i - stack.Peek() - 1;
        int boundedHeight = Math.Min(height[i], height[stack.Peek()]) - height[top];
        water += distance * boundedHeight;
    }
    stack.Push(i);
}
Console.WriteLine(water);

medium

A. 5

B. 8

C. 7

D. 6

Solution

1. Step 1: Trace the stack operations and water calculation

   The code calculates trapped water for the given height array using stack logic. The total trapped water is 6 units.

2. Step 2: Confirm calculation matches known example

   This is a classic example where trapped water is known to be 6 units for the given heights.

3. Final Answer:

   6 -> Option D

4. Quick Check:

   Trapped water for given heights = 6 [OK]

Hint: Classic example traps 6 units water [OK]

Common Mistakes:

• Miscounting distance or bounded height
• Forgetting to check stack empty before popping
• Mixing up indices and heights

4. Identify the bug in the following C# code snippet for trapping rain water using stack:

int[] height = {4,2,0,3,2,5};
int water = 0;
Stack<int> stack = new Stack<int>();
for (int i = 0; i < height.Length; i++) {
    while (stack.Count > 0 && height[i] >= height[stack.Peek()]) {
        int top = stack.Pop();
        if (stack.Count == 0) break;
        int distance = i - stack.Peek() - 1;
        int boundedHeight = Math.Min(height[i], height[stack.Peek()]) - height[top];
        water += distance * boundedHeight;
    }
    stack.Push(i);
}
Console.WriteLine(water);

medium

A. The distance calculation is incorrect

B. The stack should be a Queue instead

C. The comparison should be > instead of >= in the while condition

D. The boundedHeight calculation should use Max instead of Min

Solution

1. Step 1: Analyze the while loop condition

   The condition uses >= which causes incorrect popping when heights are equal, leading to wrong water calculation.

2. Step 2: Correct condition and explain impact

   Changing >= to > fixes the logic by only popping when current height is strictly greater, preserving correct boundaries.

3. Final Answer:

   The comparison should be > instead of >= in the while condition -> Option C

4. Quick Check:

   Use > not >= in while condition [OK]

Hint: Use > not >= to avoid wrong pops [OK]

Common Mistakes:

• Using >= causes extra pops and wrong water
• Confusing stack with queue
• Incorrect distance or boundedHeight formulas

5. Given the height array int[] height = {5,2,1,2,1,5};, what is the total trapped rain water calculated using the stack-based algorithm?

hard

A. 12

B. 10

C. 8

D. 14

Solution

1. Step 1: Visualize trapped water between bars

   Between the two 5-height bars at ends, water is trapped over lower bars: (5-2)+(5-1)+(5-2)+(5-1) = 3+4+3+4 but we must count carefully by positions.

2. Step 2: Calculate trapped water using stack logic

   Trapped water units are 3 (between 5 and 2), 1 (between 2 and 1), 3 (between 2 and 1), and 5 (between 1 and 5), total 12 units.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   Trapped water total = 12 units [OK]

Hint: Sum water trapped between highest bars [OK]

Common Mistakes:

• Adding heights instead of differences
• Ignoring boundaries at array ends
• Miscounting trapped water units