Kth Largest Element in Array

Problem Statement

LeetCode #215 - Kth Largest Element in Array

Solve this classic coding interview problem efficiently using multiple approaches.

What to notice first

• Understand the problem constraints and requirements.
• Consider multiple approaches with different trade-offs.
• Pattern mastery comes from knowing when to use each technique.

Examples

nums	k	Output	Explanation
[3,2,1,5,6,4]	2	5	Sorted: [1,2,3,4,5,6]. 2nd largest = 5
[3,2,3,1,2,4,5,5,6]	4	4	Sorted: [1,2,2,3,3,4,5,5,6]. 4th largest = 4
[1]	1	1	Single element
[7,7,7,7]	2	7	All same value

Constraints

• 1 <= k <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4

Real-World Applications

Where this pattern appears

• Application 1 — describe where this is used
• Application 2 — describe where this is used
• Application 3 — describe where this is used

Complexity Comparison

Approach	Time	Space	Best When
Min Heap	O(n log k)	O(k)	Most cases — k is small
QuickSelect	O(n)	O(1)	Average case optimal
Brute Force (Sort)	O(n log n)	O(1)	Learning or small arrays

Which approach should you learn first?

• Pick Min Heap for a balanced, interview-ready solution.
• Pick QuickSelect if you want the theoretical average case optimal solution.
• Pick Brute Force if you are learning the problem from scratch.

Best For Most Cases

Min Heap

O(n log k) time · O(k) space

Optimal Average Case

QuickSelect

O(n) time · O(1) space

Simple to Learn

Brute Force

O(n log n) time · O(1) space

Approach 1: Min Heap (Recommended)

★ Recommended

Maintain a min heap of size k containing the k largest elements. Iterate through the array and keep only the k largest elements in the heap. The root of the heap is the kth largest.

⏱ Time O(n log k) n iterations, each O(log k) 💾 Space O(k) Heap of k elements

Solution Code

Python

kth_largest_element_in_array_min_heap.py

from typing import List


def kth_largest_element_in_array_min_heap(nums: List[int]) -> int:
    """
    Kth Largest Element In Array - Min Heap approach.

    Time: O(n), Space: O(1) or O(n) depending on approach
    """
    pass


if __name__ == "__main__":
    # Test cases
    pass

C++

kth_largest_element_in_array_min_heap.cpp

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    int kth_largest_element_in_array_min_heap(vector<int>& nums) {
        // Kth Largest Element In Array - Min Heap approach
        return 0;
    }
};

int main() {
    return 0;
}

Java

kth_largest_element_in_array_min_heap.java

import java.util.*;

class Solution {
    public int kth_largest_element_in_array_min_heap(int[] nums) {
        // Kth Largest Element In Array - Min Heap approach
        return 0;
    }

    public static void main(String[] args) {
        // Test cases
    }
}

JavaScript

kth_largest_element_in_array_min_heap.js

/**
 * {@param {number[]} nums}
 * {@return {number}}
 */
var kth_largest_element_in_arrayMinheap = function(nums) {
    // Kth Largest Element In Array - Min Heap approach
    return 0;
};

if (require.main === module) {
    // Test cases
}

Rust

kth_largest_element_in_array_min_heap.rs

pub fn kth_largest_element_in_array_min_heap(nums: Vec<i32>) -> i32 {
    // Kth Largest Element In Array - Min Heap approach
    0
}

fn main() {
    // Test cases
}

Go

kth_largest_element_in_array_min_heap.go

package main

import "fmt"

func kth_largest_element_in_arrayMinheap(nums []int) int {
    // Kth Largest Element In Array - Min Heap approach
    return 0
}

func main() {
    // Test cases
}

Approach 2: QuickSelect

🎯 Interview Favourite

Use the QuickSelect algorithm (based on QuickSort partition) to find the kth largest element without fully sorting. Average time is O(n).

⏱ Time O(n) Average case 💾 Space O(1) Constant

Solution Code

Python

kth_largest_element_in_array_quickselect.py

from typing import List


def kth_largest_element_in_array_quickselect(nums: List[int]) -> int:
    """
    Kth Largest Element In Array - Quickselect approach.

    Time: O(n), Space: O(1) or O(n) depending on approach
    """
    pass


if __name__ == "__main__":
    # Test cases
    pass

C++

kth_largest_element_in_array_quickselect.cpp

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    int kth_largest_element_in_array_quickselect(vector<int>& nums) {
        // Kth Largest Element In Array - Quickselect approach
        return 0;
    }
};

int main() {
    return 0;
}

Java

kth_largest_element_in_array_quickselect.java

import java.util.*;

class Solution {
    public int kth_largest_element_in_array_quickselect(int[] nums) {
        // Kth Largest Element In Array - Quickselect approach
        return 0;
    }

    public static void main(String[] args) {
        // Test cases
    }
}

JavaScript

kth_largest_element_in_array_quickselect.js

/**
 * {@param {number[]} nums}
 * {@return {number}}
 */
var kth_largest_element_in_arrayQuickselect = function(nums) {
    // Kth Largest Element In Array - Quickselect approach
    return 0;
};

if (require.main === module) {
    // Test cases
}

Rust

kth_largest_element_in_array_quickselect.rs

pub fn kth_largest_element_in_array_quickselect(nums: Vec<i32>) -> i32 {
    // Kth Largest Element In Array - Quickselect approach
    0
}

fn main() {
    // Test cases
}

Go

kth_largest_element_in_array_quickselect.go

package main

import "fmt"

func kth_largest_element_in_arrayQuickselect(nums []int) int {
    // Kth Largest Element In Array - Quickselect approach
    return 0
}

func main() {
    // Test cases
}

Approach 3: Brute Force (Sort)

✓ Simple

Sort the array in descending order and return the element at index k-1. Simple and straightforward for learning.

⏱ Time O(n log n) Sorting dominant 💾 Space O(1) Constant

Solution Code

Python

kth_largest_element_in_array_brute_force.py

from typing import List


def kth_largest_element_in_array_brute_force(nums: List[int]) -> int:
    """
    Kth Largest Element In Array - Brute Force approach.

    Time: O(n), Space: O(1) or O(n) depending on approach
    """
    pass


if __name__ == "__main__":
    # Test cases
    pass

C++

kth_largest_element_in_array_brute_force.cpp

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    int kth_largest_element_in_array_brute_force(vector<int>& nums) {
        // Kth Largest Element In Array - Brute Force approach
        return 0;
    }
};

int main() {
    return 0;
}

Java

kth_largest_element_in_array_brute_force.java

import java.util.*;

class Solution {
    public int kth_largest_element_in_array_brute_force(int[] nums) {
        // Kth Largest Element In Array - Brute Force approach
        return 0;
    }

    public static void main(String[] args) {
        // Test cases
    }
}

JavaScript

kth_largest_element_in_array_brute_force.js

/**
 * {@param {number[]} nums}
 * {@return {number}}
 */
var kth_largest_element_in_arrayBruteforce = function(nums) {
    // Kth Largest Element In Array - Brute Force approach
    return 0;
};

if (require.main === module) {
    // Test cases
}

Rust

kth_largest_element_in_array_brute_force.rs

pub fn kth_largest_element_in_array_brute_force(nums: Vec<i32>) -> i32 {
    // Kth Largest Element In Array - Brute Force approach
    0
}

fn main() {
    // Test cases
}

Go

kth_largest_element_in_array_brute_force.go

package main

import "fmt"

func kth_largest_element_in_arrayBruteforce(nums []int) int {
    // Kth Largest Element In Array - Brute Force approach
    return 0
}

func main() {
    // Test cases
}

Common mistakes

Watch for these pitfalls

• Mistake 1 — explain what to watch for
• Mistake 2 — explain what to watch for
• Mistake 3 — explain what to watch for

Related Problems

• Two Sum ↗ Easy #1
• Contains Duplicate ↗ Easy #217

Interview Tips

Key discussion points

• Trade-offs between different approaches
• Edge cases to consider
• Possible follow-up questions
• How to extend the solution