Sponsored
Sponsored
This approach uses a hash map to count the frequency of each element. We then use a min-heap to keep track of the top k elements.
Time Complexity: O(n log n) due to sorting.
Space Complexity: O(n) for storing frequencies.
1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4
5#define MAX 10000
6
7typedef struct {
8 int value;
9 int count;
10} Freq;
11
12int compare(const void *a, const void *b) {
13 return ((Freq *)b)->count - ((Freq *)a)->count;
14}
15
16int* topKFrequent(int* nums, int numsSize, int k, int* returnSize) {
17 int freqMap[2 * MAX + 1] = {0};
18 Freq freqArray[numsSize];
19 int uniqueCount = 0;
20
21 for(int i = 0; i < numsSize; i++) {
22 freqMap[nums[i] + MAX]++;
23 }
24
25 for(int i = 0; i < 2 * MAX + 1; i++) {
26 if(freqMap[i]) {
27 freqArray[uniqueCount].value = i - MAX;
28 freqArray[uniqueCount].count = freqMap[i];
29 uniqueCount++;
30 }
31 }
32
33 qsort(freqArray, uniqueCount, sizeof(Freq), compare);
34
35 *returnSize = k;
36 int *result = (int*)malloc(sizeof(int) * k);
37 for(int i = 0; i < k; i++) {
38 result[i] = freqArray[i].value;
39 }
40 return result;
41}
42
43int main() {
44 int nums[] = {1, 1, 1, 2, 2, 3};
45 int k = 2;
46 int returnSize;
47 int* result = topKFrequent(nums, 6, k, &returnSize);
48 for(int i = 0; i < returnSize; i++) {
49 printf("%d ", result[i]);
50 }
51 free(result);
52 return 0;
53}
54We use a frequency map to track occurrences of each number. Then, we create a struct array for frequencies, sort it, and return the top k elements.
This approach involves using bucket sort where we create buckets for frequency counts and then extract the top k frequent elements.
Time Complexity: O(n + k).
Space Complexity: O(n).
1#include <iostream>
2#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;
vector<int> topKFrequent(vector<int>& nums, int k) {
unordered_map<int, int> freqMap;
vector<vector<int>> buckets(nums.size() + 1);
for (int num : nums) {
freqMap[num]++;
}
for (auto& p : freqMap) {
buckets[p.second].push_back(p.first);
}
vector<int> result;
for (int i = buckets.size() - 1; i >= 0 && result.size() < k; --i) {
for (int num : buckets[i]) {
result.push_back(num);
if (result.size() == k) break;
}
}
return result;
}
int main() {
vector<int> nums = {1, 1, 1, 2, 2, 3};
int k = 2;
vector<int> result = topKFrequent(nums, k);
for (int num : result) {
cout << num << " ";
}
return 0;
}
Frequency occurrences are placed in buckets. The largest buckets represent the most frequent elements.