Top K Frequent Elements

Published at16 Mar 2026

Hash Table Medium 19 views

Like0

You are given an integer array and a number k. You need to return the k values that appear most often.

This is not asking for the elements in their original order, and it is not asking for their frequencies. The answer should be the actual values whose counts are highest. If nums = [1,1,1,2,2,3] and k = 2, the correct answer is [1,2] because 1 appears three times and 2 appears twice.

If the array is just [1] and k = 1, then the answer is simply [1].

So the task is to measure frequency first, then return the values belonging to the top k counts.

Example Input & Output

Example 1

Input

nums = [1,1,1,2,2,3], k = 2

Output

[1,2]

Explanation

1 appears 3 times, 2 appears 2 times.

Example 2

Input

nums = [1], k = 1

Output

[1]

Explanation

Only one element exists.

Example 3

Input

nums = [4,4,4,5,5,6], k = 2

Output

[4,5]

Explanation

4 and 5 are the two most frequent values.

Algorithm Flow

Recommendation Algorithm Flow for Top K Frequent Elements

Solution Approach

The natural first step is frequency counting with a hash map. Walk through the array and store how many times each value appears. After that pass, you know the exact frequency of every distinct number.

The second step is choosing the top k values. One straightforward way is to turn the frequency map into a list of [value, count] pairs, sort that list by count in descending order, and then take the first k values.

In outline, the process is:

1. Count each number with a map.

2. Convert the map into pairs like [num, count].

3. Sort those pairs so the largest counts come first.

4. Extract the first k numbers.

This is easy to understand because the map handles counting and the sorted pair list handles ranking.

Some versions of the problem can also be solved with buckets or a heap for better asymptotic performance, but the hash table plus sort approach is still a strong explanation-first solution. Its time complexity is usually O(n + m log m), where m is the number of distinct values, and the extra space is O(m).

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

java

import java.util.*;
class Solution {
    public int[] top_k_frequent_elements(int[] nums, int k) {
        Map<Integer, Integer> freq = new HashMap<>();
        for (int x : nums) freq.put(x, freq.getOrDefault(x, 0) + 1);
        List<Map.Entry<Integer, Integer>> arr = new ArrayList<>(freq.entrySet());
        arr.sort((a, b) -> b.getValue() - a.getValue());
        int[] res = new int[k];
        for (int i = 0; i < k; i++) res[i] = arr.get(i).getKey();
        return res;
    }
}

javascript

function top_k_frequent_elements(nums, k) {
    const freq = {};
    for (let i = 0; i < nums.length; i++) {
        const x = nums[i];
        freq[x] = (freq[x] || 0) + 1;
    }
    const pairs = Object.keys(freq).map(key => [parseInt(key), freq[key]]);
    pairs.sort((a, b) => b[1] - a[1]);
    const res = [];
    for (let i = 0; i < k; i++) res.push(pairs[i][0]);
    return res;
}

php

<?php
function top_k_frequent_elements($nums, $k) {
    $freq = [];
    foreach ($nums as $x) {
        $key = (string)$x;
        $freq[$key] = ($freq[$key] ?? 0) + 1;
    }
    arsort($freq);
    $keys = array_keys($freq);
    $res = [];
    for ($i = 0; $i < $k; $i++) $res[] = intval($keys[$i]);
    return $res;
}
?>

python

from typing import List

def top_k_frequent_elements(nums: List[int], k: int) -> List[int]:
    freq = {}
    for x in nums:
        freq[x] = freq.get(x, 0) + 1
    pairs = sorted(freq.items(), key=lambda p: p[1], reverse=True)
    return [pairs[i][0] for i in range(k)]

rust

use std::collections::HashMap;
fn top_k_frequent_elements(nums: Vec<i32>, k: i32) -> Vec<i32> {
    let mut freq: HashMap<i32, i32> = HashMap::new();
    for x in nums {
        *freq.entry(x).or_insert(0) += 1;
    }
    let mut arr: Vec<(i32, i32)> = freq.into_iter().collect();
    arr.sort_by(|a, b| b.1.cmp(&a.1));
    let mut res: Vec<i32> = Vec::new();
    for i in 0..k as usize {
        res.push(arr[i].0);
    }
    res
}

typescript

function top_k_frequent_elements(nums: number[], k: number): number[] {
    var freq: { [key: string]: number } = {};
    for (var i = 0; i < nums.length; i++) {
        var key = String(nums[i]);
        freq[key] = (freq[key] || 0) + 1;
    }
    var keys = Object.keys(freq);
    var pairs: [number, number][] = [];
    for (var j = 0; j < keys.length; j++) {
        pairs.push([parseInt(keys[j], 10), freq[keys[j]]]);
    }
    pairs.sort(function(a, b){ return b[1] - a[1]; });
    var res: number[] = [];
    for (var p = 0; p < k; p++) res.push(pairs[p][0]);
    return res;
}

Related Hash Table Challenges

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this Challenge.

Top K Frequent Elements

Example Input & Output

Algorithm Flow

Solution Approach

Best AnswersThese are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

Solutions Coming Soon

Related Hash Table Challenges

Duplicate Indices Map

First Unique Character

Contains Duplicate

Valid Anagram

Ransom Note

Two Sum Indices

Comments (0)

Join the Discussion

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.