Kth Smallest Element in a Sorted Matrix - Practice Coding Problems

Kth Smallest Element in a Sorted Matrix - Problem

Find the Kth Smallest Element in a Sorted Matrix

You're given an n × n matrix where both rows and columns are sorted in ascending order. Your task is to find the kth smallest element in the entire matrix.

🎯 Goal: Return the kth smallest value (not kth distinct value)
📊 Input: A sorted n×n matrix and integer k
🔍 Output: The kth smallest element

Important: You must solve this with memory complexity better than O(n²) - you cannot simply flatten the matrix into an array!

Example:
Matrix: [[1,5,9],[10,11,13],[12,13,15]]
k = 8
Output: 13 (the 8th smallest element)

Input & Output

example_1.py — Basic Case

$ Input: matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8

› Output: 13

💡 Note: The elements in sorted order are [1,5,9,10,11,12,13,13,15]. The 8th smallest element is 13.

example_2.py — Small Matrix

$ Input: matrix = [[-5]], k = 1

› Output: -5

💡 Note: There's only one element in the matrix, so the 1st smallest is -5.

example_3.py — First Element

$ Input: matrix = [[1,2],[1,3]], k = 1

› Output: 1

💡 Note: The elements in sorted order are [1,1,2,3]. The 1st smallest element is 1.

Visualization

Tap to expand

Understanding the Visualization

Naive Approach

Collect all elements and sort them - requires O(n²) space

Min-Heap Approach

Use a heap to track only the k smallest candidates we've seen

Binary Search Magic

Search on VALUES not positions - count elements ≤ candidate value

Efficient Counting

Use sorted property: start bottom-left, move systematically

Key Takeaway

🎯 Key Insight: Binary search on the VALUE RANGE combined with efficient counting using the sorted matrix property gives us optimal O(n log(max-min)) time and O(1) space complexity!

Time & Space Complexity

Time Complexity

⏱️

O(k log k)

We pop k elements from heap, each operation takes O(log k) time

⚡ Linearithmic

Space Complexity

O(min(k, n))

Heap stores at most min(k, n) elements plus visited set

⚡ Linearithmic Space

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 300
1 ≤ k ≤ n²
-10⁹ ≤ matrix[i][j] ≤ 10⁹
All the rows and columns of matrix are guaranteed to be sorted in non-decreasing order

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 31

The optimal solution uses binary search on the value range rather than searching through positions. We search between the minimum and maximum possible values, and for each candidate value, count how many elements are ≤ that value using the sorted matrix property. This achieves O(n log(max-min)) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Min-Heap Approach	O(k log k)	O(min(k, n))	Use a min-heap to track the k smallest elements without storing all n² elements
Binary Search on Value Range (Optimal)	O(n log(max - min))	O(1)	Binary search on the range of possible values, counting elements ≤ mid

Min-Heap Approach — Algorithm Steps

Initialize min-heap with the top-left element (matrix[0][0])
Use a visited set to avoid adding duplicate elements
Pop the minimum element from heap k times
For each popped element, add its right and bottom neighbors to heap
The kth popped element is our answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with top-left element in heap

Pop minimum

Remove smallest element from heap

Add neighbors

Add right and bottom neighbors to heap

Repeat

Continue until k elements are processed

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int val, row, col;
} Element;

int compare(const void* a, const void* b) {
    return ((Element*)a)->val - ((Element*)b)->val;
}

int kthSmallest(int** matrix, int matrixSize, int* matrixColSize, int k) {
    int n = matrixSize;
    Element* heap = (Element*)malloc(k * sizeof(Element));
    int heapSize = 0;
    char visited[1000][20]; // Simple visited tracking
    int visitedCount = 0;
    
    heap[heapSize++] = (Element){matrix[0][0], 0, 0};
    sprintf(visited[visitedCount++], "0,0");
    
    for (int i = 0; i < k; i++) {
        qsort(heap, heapSize, sizeof(Element), compare);
        Element curr = heap[0];
        
        // Remove from heap (shift left)
        for (int j = 0; j < heapSize - 1; j++) {
            heap[j] = heap[j + 1];
        }
        heapSize--;
        
        if (i == k - 1) {
            free(heap);
            return curr.val;
        }
        
        // Add neighbors (simplified implementation)
        if (curr.col + 1 < n && heapSize < k) {
            heap[heapSize++] = (Element){matrix[curr.row][curr.col + 1], curr.row, curr.col + 1};
        }
        if (curr.row + 1 < n && heapSize < k) {
            heap[heapSize++] = (Element){matrix[curr.row + 1][curr.col], curr.row + 1, curr.col};
        }
    }
    
    free(heap);
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(k log k)

We pop k elements from heap, each operation takes O(log k) time

⚡ Linearithmic

Space Complexity

O(min(k, n))

Heap stores at most min(k, n) elements plus visited set

⚡ Linearithmic Space

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 300
1 ≤ k ≤ n²
-10⁹ ≤ matrix[i][j] ≤ 10⁹
All the rows and columns of matrix are guaranteed to be sorted in non-decreasing order

58.3K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Min-Heap Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler