Top K Elements in List – Python

Last updated on February 5th, 2025 at 03:52 am

In this article, we’ll explore what the Top K Elements in List mean, how to solve it, and even provide some examples to make it easy to understand.

1. What are Top K Elements in List?

The top K elements in a list refer to the K largest or smallest elements in a given list. The list can contain any type of data, such as integers, strings, or objects. The top K elements can be determined based on various criteria, such as their frequency, magnitude, or alphabetical order.

2. Why are Top K Elements Important?

Finding the top K elements in a list has numerous applications in real-world scenarios. Example –

• Data Analysis: Identifying the most frequent elements can help you understand the distribution of data.
• Recommendation Systems: User preferences can help you recommend products or services to users.
• Algorithm Optimization: Reduce the computational complexity and improve performance.

3. Top K Elements Leetcode Problem

The Top K Elements Leetcode problem is a popular coding challenge that requires you to find the top K elements in a list. The problem statement is as follows:

Given a non-empty array of integers, return the k most frequent elements.

4. Approaches to Find Top K Elements in a List

To solve the Top K Elements problem, we can use various approaches. Some common approaches:

4.1. Sorting Approach

The simplest way to find the Top K Elements is by sorting the list and then selecting the first K elements.

def top_k_elements_sorting(nums, k):
    nums.sort(reverse=True)
    return nums[:k]

numbers = [3, 1, 5, 12, 2, 11]
k = 3
print(top_k_elements_sorting(numbers, k))  


## Output: 
[12, 11, 5]

Pros: Easy to implement and understand.
Cons: Inefficient for large datasets as it requires O(n log n) time complexity.

Time Complexity: O(n log n)
Space Complexity: O(1)

4.2. Heap Approach – Using a Min-Heap

An efficient approach is to use a Min-Heap, which allows you to maintain the top K elements in O(n log k) time complexity

import heapq

def top_k_elements_heap(nums, k):
    return heapq.nlargest(k, nums)

numbers = [3, 1, 5, 12, 2, 11]
k = 3
print(top_k_elements_heap(numbers, k))  


## Output: 
[12, 11, 5]

Pros: More efficient for large datasets.
Cons: Slightly more complex to implement.

Time Complexity: O(n log k)
Space Complexity: O(k)

4.3. Quickselect Approach

The Quickselect algorithm is an optimization of the QuickSort algorithm and can find the Top K Elements in O(n) average time complexity.

def quickselect(nums, k):
    if len(nums) == 1:
        return nums[0]

    pivot = nums[len(nums) // 2]
    left = [x for x in nums if x > pivot]
    middle = [x for x in nums if x == pivot]
    right = [x for x in nums if x < pivot]

    if k <= len(left):
        return quickselect(left, k)
    elif k <= len(left) + len(middle):
        return pivot
    else:
        return quickselect(right, k - len(left) - len(middle))

def top_k_elements_quick(nums, k):
    pivot = quickselect(nums, k)
    return [x for x in nums if x >= pivot]

numbers = [3, 1, 5, 12, 2, 11]
k = 3
print(top_k_elements_quick(numbers, k))  


## Output: 
[5, 12, 11]

Time Complexity: O(n) on average
Space Complexity: O(n)

5. Top K Elements in List Leetcode: Common Patterns

When you’re solving Top K Elements problems on Leetcode, you’ll often find different versions of the problem. some common patterns:

• Top K Frequent Elements: Find the K most frequent elements in a list.
  • Leetcode Problem: Top K frequent words, Top K frequent elements
• Kth Largest Element: Find the Kth largest element in an unsorted array.
• K Closest Points to Origin: Find the K points closest to the origin in a 2D plane.

FAQs