Search in 2D Matrix in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind searching in a 2D matrix where each row and column is sorted?

Start from the top-right corner and move left if the current number is too big, or move down if the current number is too small. This way, you eliminate a row or a column each step.

beginner

Why is starting from the top-right corner effective in searching a sorted 2D matrix?

Because from the top-right corner, moving left decreases the value and moving down increases the value, helping to decide which direction to go based on the target.

intermediate

What is the time complexity of searching in a sorted 2D matrix using the top-right corner approach?

O(m + n), where m is the number of rows and n is the number of columns, because each step moves either one row down or one column left.

beginner

Show the Python code snippet to search a target in a 2D matrix sorted by rows and columns.

def search_matrix(matrix, target): if not matrix or not matrix[0]: return False row, col = 0, len(matrix[0]) - 1 while row < len(matrix) and col >= 0: if matrix[row][col] == target: return True elif matrix[row][col] > target: col -= 1 else: row += 1 return False

beginner

What happens if the target is smaller than the current element in the top-right corner search?

You move left to the previous column because values decrease to the left, so the target might be there.

In a sorted 2D matrix, where should you start searching for a target to use the efficient approach?

A Top-right corner

B Bottom-left corner

C Top-left corner

D Bottom-right corner

Starting at the top-right corner allows moving left or down to eliminate rows or columns efficiently.

If the current element is less than the target, what is the next move in the search?

A Move down

B Move up

C Move left

D Move right

If the current element is smaller, move down to find larger elements.

What is the worst-case time complexity of searching in a sorted 2D matrix using the top-right corner method?

A O(m * n)

B O(m + n)

C O(1)

D O(log(m * n))

Each step moves either one row down or one column left, so total steps are at most m + n.

What should you do if the current element equals the target during the search?

A Continue searching

B Move left

C Move down

D Return True

If the current element matches the target, the search is successful.

If the matrix is empty or has empty rows, what should the search function return?

A Error

B True

C False

D None

If the matrix or its rows are empty, the target cannot be found, so return False.

Explain the step-by-step process to search for a target in a 2D matrix sorted by rows and columns.

Think about how moving left or down helps narrow the search.

Write the Python function to search a target in a sorted 2D matrix and explain its time complexity.

Use the top-right corner approach and explain why each step reduces search space.

Practice

1. What is the main idea behind searching an element in a 2D matrix where each row and column is sorted in ascending order?

easy

A. Start from top-right corner and move left or down based on comparison

B. Start from bottom-left corner and move left or down based on comparison

C. Search each element one by one from left to right, top to bottom

D. Use binary search on each row independently

Solution

1. Step 1: Understand matrix properties and use top-right corner

   Each row and column is sorted ascending, so top-right element is largest in its row and smallest in its column. If target is less than current element, move left; if greater, move down.

2. Final Answer:

   Start from top-right corner and move left or down based on comparison -> Option A

3. Quick Check:

   Top-right start = efficient search [OK]

Hint: Start at top-right to decide direction quickly [OK]

Common Mistakes:

• Starting from bottom-left without adjusting logic
• Searching all elements linearly
• Using binary search on each row without considering columns

2. Which of the following Python code snippets correctly initializes a 2D matrix named matrix with 3 rows and 4 columns filled with zeros?

easy

A. matrix = [[0]*4]*3

B. matrix = [[0]*3 for _ in range(4)]

C. matrix = [0]*3*[0]*4

D. matrix = [[0 for _ in range(4)] for _ in range(3)]

Solution

1. Step 1: Understand list comprehension for 2D matrix and check options

   Use nested list comprehension [[0 for _ in range(4)] for _ in range(3)] to create independent 3 rows with 4 zeros each. A shares references, B wrong dimensions, C syntax invalid.

2. Final Answer:

   matrix = [[0 for _ in range(4)] for _ in range(3)] -> Option D

3. Quick Check:

   Nested list comprehension = correct matrix init [OK]

Hint: Use nested list comprehension for independent rows [OK]

Common Mistakes:

• Using [[0]*4]*3 causes shared references
• Multiplying lists incorrectly
• Swapping rows and columns in comprehension

3. What will be the output of the following code?

matrix = [
  [1, 3, 5, 7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 3

row, col = 0, len(matrix[0]) - 1
found = False
while row < len(matrix) and col >= 0:
    if matrix[row][col] == target:
        found = True
        break
    elif matrix[row][col] > target:
        col -= 1
    else:
        row += 1
print(found)

medium

A. IndexError

B. False

C. True

D. SyntaxError

Solution

1. Step 1: Trace starting position and comparisons until target found

   Start at top-right: matrix[0][3] = 7 > 3, move left to col=2; matrix[0][2] = 5 > 3, move left col=1; matrix[0][1] = 3 == target, found = True.

2. Final Answer:

   True -> Option C

3. Quick Check:

   Found target 3 = True [OK]

Hint: Start top-right, move left/down until found or out of bounds [OK]

Common Mistakes:

• Confusing row and column indices
• Not updating row or col correctly
• Assuming linear search needed

4. The following code is intended to search for a target in a sorted 2D matrix but does not work correctly. What is the error?

def search_matrix(matrix, target):
    row = 0
    col = len(matrix[0])
    while row < len(matrix) and col >= 0:
        if matrix[row][col] == target:
            return True
        elif matrix[row][col] > target:
            col -= 1
        else:
            row += 1
    return False

medium

A. col should start at len(matrix[0]) - 1, not len(matrix[0])

B. row should start at len(matrix) - 1

C. The while loop condition should use 'or' instead of 'and'

D. The function should return null instead of false

Solution

1. Step 1: Check initial column index and correct start

   col is set to len(matrix[0]) which is out of range (indexing starts at 0). It should be len(matrix[0]) - 1 to start at last valid column index.

2. Final Answer:

   col should start at len(matrix[0]) - 1, not len(matrix[0]) -> Option A

3. Quick Check:

   Index out of range fix = col start - 1 [OK]

Hint: Start col at last index: length minus one [OK]

Common Mistakes:

• Starting col at length causes IndexError
• Changing row start incorrectly
• Using wrong loop condition

5. Given a 2D matrix where each row and column is sorted ascending, write a function to count how many times a target number appears. Which approach is most efficient?

hard

A. Traverse entire matrix and count matches (O(m*n))

B. Use binary search on each row and sum counts (O(m*log n))

C. Start from top-right and move left/down counting matches (O(m+n))

D. Flatten matrix to 1D list and use built-in count method

Solution

1. Step 1: Analyze time complexities and correct approach

   Full traversal O(m*n), top-right single pass misses duplicates off the path, flatten O(m*n); binary search on each row finds leftmost/rightmost target positions to compute count per row, total O(m*log n) efficient and correct.

2. Final Answer:

   Use binary search on each row and sum counts (O(m*log n)) -> Option B

3. Quick Check:

   Binary per row = efficient count [OK]

Hint: Binary search range in each row [OK]

Common Mistakes:

• Using full traversal wasting time
• Flattening matrix loses sorted structure
• Top-right movement misses off-path duplicates