Kth Smallest Element in a Sorted Matrix

Kth Smallest Element in a Sorted Matrix - Problem

Given an n x n matrix where each of the rows and columns is sorted in ascending order, return the k^th smallest element in the matrix.

Note that it is the k^th smallest element in the sorted order, not the k^th distinct element.

You must find a solution with a memory complexity better than O(n²).

Input & Output

Example 1 — Basic 3x3 Matrix

$ 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 is 13.

Example 2 — Small Matrix

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

› Output: -5

💡 Note: Single element matrix, the 1st (and only) smallest element is -5.

Example 3 — First Element

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

› Output: 1

💡 Note: Elements in order: [1,1,2,3]. The 1st smallest is 1 (top-left).

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The optimal solution uses binary search on the answer space with O(n log(max-min)) time and O(1) space. The key insight is to search for the answer value rather than extracting elements, using the matrix's sorted property to efficiently count elements ≤ any target value.

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Greedy

⏱️ Time: N/A Space: N/A

Binary Search on Answer Space

⏱️ Time: O(n log(max - min)) Space: O(1)

Instead of finding elements directly, we binary search on the range of possible answers (from matrix[0][0] to matrix[n-1][n-1]). For each candidate answer, we count how many elements in the matrix are ≤ that value using the sorted property.

Brute Force - Flatten and Sort

⏱️ Time: O(n² log n) Space: O(n²)

The simplest approach is to flatten the entire matrix into a single array, sort it completely, and return the element at index k-1. While straightforward, this violates the O(n²) memory constraint.

Min Heap Approach

⏱️ Time: O(k log(min(k, n))) Space: O(min(k, n))

Start with the smallest element (top-left) in a min heap, then repeatedly extract the minimum and add its right and bottom neighbors. After k extractions, we have the kth smallest element.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char* solution(char* s) {
    int len = strlen(s);
    char* stack = malloc((len + 1) * sizeof(char));
    int stackSize = 0;
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '*') {
            if (stackSize > 0) {
                // Find the smallest character
                char minChar = stack[0];
                for (int j = 1; j < stackSize; j++) {
                    if (stack[j] < minChar) {
                        minChar = stack[j];
                    }
                }
                // Remove rightmost occurrence for lexicographically smallest result
                for (int j = stackSize - 1; j >= 0; j--) {
                    if (stack[j] == minChar) {
                        for (int k = j; k < stackSize - 1; k++) {
                            stack[k] = stack[k + 1];
                        }
                        stackSize--;
                        break;
                    }
                }
            }
        } else {
            stack[stackSize++] = s[i];
        }
    }
    
    stack[stackSize] = '\0';
    return stack;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

78.5K Views

Medium Frequency

~25 min Avg. Time

3.2K 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