Kth Largest Element in an Array - Practice Coding Problems

Kth Largest Element in an Array - Problem

Imagine you're organizing a sports tournament and need to quickly find the k-th best performer from a list of scores. This problem asks you to find the k-th largest element in an unsorted integer array.

Given an integer array nums and an integer k, return the k-th largest element in the array. Note that we want the k-th largest element in sorted order, not the k-th distinct element.

Challenge: Can you solve this without fully sorting the array? There are elegant solutions that can do better than O(n log n) time complexity!

Example: In array [3,2,1,5,6,4] with k=2, the 2nd largest element is 5 (since sorted array would be [6,5,4,3,2,1]).

Input & Output

example_1.py — Basic Case

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

› Output: 5

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

example_2.py — With Duplicates

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

› Output: 4

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

example_3.py — Single Element

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

› Output: 1

💡 Note: Only one element exists, so the 1st (and only) largest element is 1

Visualization

Tap to expand

Understanding the Visualization

Choose Strategy

Select between full sorting O(n log n), min-heap O(n log k), or quickselect O(n) average

Partition/Process

Apply chosen strategy - sort all, maintain k-size heap, or partition around pivots

Extract Result

Return the k-th largest element from sorted array, heap root, or pivot position

Key Takeaway

🎯 Key Insight: You don't need to sort everything to find one element. Quickselect partitions strategically around pivots, eliminating half the search space each time, achieving O(n) average performance!

Time & Space Complexity

Time Complexity

⏱️

O(n) average, O(n²) worst case

Average case: each partition reduces problem size by half. Worst case: poor pivot choices lead to O(n²)

⚠ Quadratic Growth

Space Complexity

O(1)

In-place algorithm, only uses constant extra space for recursion variables

✓ Linear Space

Constraints

1 ≤ k ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
k is guaranteed to be valid (within array bounds)

Asked in

f Facebook 85 a Amazon 72 Apple 68 G Google 61 ⊞ Microsoft 55 in LinkedIn 43

The optimal approach uses Quickselect algorithm with average O(n) time complexity. By partitioning around pivot elements and recursing only on the side containing the k-th largest element, we avoid unnecessary sorting. Alternative approaches include Min-Heap (O(n log k)) which is efficient when k is small, and full sorting (O(n log n)) for simplicity.

Common Approaches

Approach	Time	Space	Notes
✓ Min-Heap Approach	O(n log k)	O(k)	Use a min-heap of size k to track the k largest elements
Quickselect Algorithm (Optimal)	O(n) average, O(n²) worst case	O(1)	Use divide-and-conquer partitioning to find k-th largest in average O(n) time
Brute Force (Full Sorting)	O(n log n)	O(1)	Sort the entire array and return the k-th element from the end

Min-Heap Approach — Algorithm Steps

Create a min-heap to store at most k elements
Iterate through each element in the array
If heap size < k, add the element to heap
If heap size = k and current element > heap root, remove root and add current element
Return the root of the heap (k-th largest element)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty min-heap of max size k=2

Process Elements

Add elements, maintaining only k largest

Result

Heap root is the k-th largest element

Code -

solution.c — C

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

// Simple min-heap implementation
typedef struct {
    int* data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
    heap->data = (int*)malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

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

void heapifyDown(MinHeap* heap, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int smallest = idx;
    
    if (left < heap->size && heap->data[left] < heap->data[smallest])
        smallest = left;
    if (right < heap->size && heap->data[right] < heap->data[smallest])
        smallest = right;
    
    if (smallest != idx) {
        int temp = heap->data[idx];
        heap->data[idx] = heap->data[smallest];
        heap->data[smallest] = temp;
        heapifyDown(heap, smallest);
    }
}

void push(MinHeap* heap, int val) {
    heap->data[heap->size] = val;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int pop(MinHeap* heap) {
    int root = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return root;
}

int findKthLargest(int* nums, int numsSize, int k) {
    MinHeap* heap = createHeap(k);
    
    for (int i = 0; i < numsSize; i++) {
        if (heap->size < k) {
            push(heap, nums[i]);
        } else if (nums[i] > heap->data[0]) {
            pop(heap);
            push(heap, nums[i]);
        }
    }
    
    int result = heap->data[0];
    free(heap->data);
    free(heap);
    return result;
}

int main() {
    int nums[] = {3,2,1,5,6,4};
    int k = 2;
    printf("%d\n", findKthLargest(nums, 6, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

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

⚡ Linearithmic

Space Complexity

O(k)

Min-heap stores at most k elements

✓ Linear Space

Constraints

1 ≤ k ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
k is guaranteed to be valid (within array bounds)

89.5K Views

Very High Frequency

~15 min Avg. Time

2.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