---
title: '347. Top K Frequent Elements'
description: Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order
icon: dot
topics:
  - { name: "Array", slug: "array" }
  - { name: "Hash Table", slug: "hash-table" }
  - { name: "Divide and Conquer", slug: "divide-and-conquer" }
  - { name: "Sorting", slug: "sorting" }
  - { name: "Heap (Priority Queue)", slug: "heap-priority-queue" }
  - { name: "Bucket Sort", slug: "bucket-sort" }
  - { name: "Counting", slug: "counting" }
  - { name: "Quickselect", slug: "quickselect" }
video: "YPTqKIgVk-k"
issue: "https://github.com/prdlk/leetcode/issues/31"
sidebar:
  label: 'Top K Frequent Elements'
  badge: 'Medium'
---

::::warning
Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
::::

### Example 1:
- Input: `nums = [1,1,1,2,2,3], k = 2`
- Output: `[1,2]`

### Example 2:
- Input: `nums = [1], k = 1`
- Output: `[1]`

### Example 3:
- Input: `nums = [1,2,1,2,1,2,3,1,3,2], k = 2`
- Output: `[1,2]`

### Constraints:

- `1 <= nums.length <= 10^5`
- `-10^4 <= nums[i] <= 10^4`
- `k` is in the range `[1, the number of unique elements in the array]`.
- It is guaranteed that the answer is unique.

## Approach

```mermaid
flowchart TD
  S(["topKFrequent(nums, k)"]) --> F["freq: count every value in nums"]
  F --> K["keys of freq, cast to Number"]
  K --> O["sort by freq[b] - freq[a] — most frequent first"]
  O --> R(["return slice(0, k)"])
```

## Solution

```js
/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var topKFrequent = function (nums, k) {
  const freq = {};
  for (let n of nums) freq[n] = (freq[n] || 0) + 1;

  return Object.keys(freq)
    .map(Number)
    .sort((a, b) => freq[b] - freq[a])
    .slice(0, k);
};
```