Kth Largest Element in an Array

Kth Largest Element in an Array - Problem

Given an integer array nums and an integer k, return the k-th largest element in the array.

Note that it is the k-th largest element in the sorted order, not the k-th distinct element.

Can you solve it without sorting?

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,2,1,5,6,4], k = 2

› Output: 5

💡 Note: The array sorted in descending order is [6,5,4,3,2,1]. The 2nd largest element is 5.

Example 2 — Different K

$ Input: nums = [3,2,3,1,2,4,5,5,6], k = 4

› Output: 4

💡 Note: The sorted array is [6,5,5,4,3,3,2,2,1]. The 4th largest element is 4.

Example 3 — Minimum Size

$ Input: nums = [1], k = 1

› Output: 1

💡 Note: There's only one element, so the 1st largest is 1.

Constraints

1 ≤ k ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 65 a Amazon 58 in LinkedIn 42 🍎 Apple 38 G Google 35

The key insight is that we don't need to sort the entire array - we only need to find the k-th position. The optimal approach is Quickselect with average O(n) time complexity, though a min-heap approach with O(n log k) is also efficient when k is small. Time: O(n), Space: O(1)

Common Approaches

✓ Min-Heap Approach

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

Maintain a min-heap with at most k elements. For each element in the array, add it to the heap. If heap size exceeds k, remove the smallest element. The root of the final heap is the k-th largest element.

Quickselect Algorithm

⏱️ Time: O(n) Space: O(1)

Quickselect is a selection algorithm to find the k-th smallest/largest element. It uses the partition logic of quicksort but only recurses into one side of the partition, making it more efficient than full sorting.

Sort and Index

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

The simplest approach is to sort the array in descending order and directly access the k-th element (at index k-1). This guarantees we get the correct answer but uses more time than necessary.

Min-Heap Approach — Algorithm Steps

Create a min-heap
For each element, add to heap
If heap size > k, remove minimum
Return heap root (k-th largest)

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Elements

Add elements to heap, remove smallest if size > k

Heap Maintenance

Heap root is always the k-th largest seen so far

Final Result

Heap root is the k-th largest element

Code -

solution.c — C

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

void heapifyUp(int* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap[parent] <= heap[idx]) break;
        int temp = heap[parent];
        heap[parent] = heap[idx];
        heap[idx] = temp;
        idx = parent;
    }
}

void heapifyDown(int* heap, int size, int idx) {
    while (1) {
        int smallest = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < size && heap[left] < heap[smallest])
            smallest = left;
        if (right < size && heap[right] < heap[smallest])
            smallest = right;
        
        if (smallest == idx) break;
        
        int temp = heap[idx];
        heap[idx] = heap[smallest];
        heap[smallest] = temp;
        idx = smallest;
    }
}

int solution(int* nums, int numsSize, int k) {
    int heap[1000];
    int heapSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        heap[heapSize] = nums[i];
        heapifyUp(heap, heapSize);
        heapSize++;
        
        if (heapSize > k) {
            heap[0] = heap[heapSize - 1];
            heapSize--;
            heapifyDown(heap, heapSize, 0);
        }
    }
    
    return heap[0];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[10000];
    int numsSize = 0;
    char* token = strtok(line, "[,]\n");
    while(token != NULL) {
        if(strlen(token) > 0 && token[0] != '[' && token[0] != ']') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

Process n elements, each heap operation takes O(log k) time

✓ Linear Growth

Space Complexity

O(k)

Min-heap stores at most k elements

✓ Linear Space

78.0K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Min-Heap Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler