leetcode-347-前K个高频元素(top k frequent elements)-java
题目及测试
package pid374;
/* 前K个高频元素
给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:
输入: nums = [1], k = 1
输出: [1]
说明：
你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。
*/
import java.util.List;
public class main {
public static void main(String[] args) {
int[][] testTable = {{1,1,1,2,2,3},{1}};
int[] testTable2={2,1};
for (int i=0;i rtn;
Solution solution=new Solution();
long begin = System.currentTimeMillis();
for (int i = 0; i < ito.length; i++) {
System.out.print(ito[i]+" ");
}
System.out.println();
//开始时打印数组
System.out.println("ito2="+ito2);
rtn = solution.topKFrequent(ito,ito2);//执行程序
long end = System.currentTimeMillis();
System.out.println(ito + ": rtn=" );
System.out.println( " rtn=" );
for (int i = 0; i < rtn.size(); i++) {
System.out.print(rtn.get(i)+" ");
}//打印结果几数组
System.out.println();
System.out.println("耗时：" + (end - begin) + "ms");
System.out.println("-------------------");
}
}
解法1（成功，22ms，很快）
其实该提就是对map的value进行排序，方法
List> list = new ArrayList>(map.entrySet());
Collections.sort(list, new Comparator>() {
@Override
public int compare(Entry o1,
Entry o2) {
if(o2.getValue().compareTo(o1.getValue())>0){
return 1;
}else if(o2.getValue().compareTo(o1.getValue())<0){
return -1;
} else {
return 0;
}
} 先建立map，key为int[i]，value为该值得次数，然后将map化为set，化为list，用collections。Sort对list排序，然后取出前k个的key即可
package pid374;
import java.lang.reflect.Array;
import java.util.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
class Solution {
public List topKFrequent(int[] nums, int k) {
HashMap map=new HashMap<>();
List result=new ArrayList<>();
int length=nums.length;
for(int i=0;i> list = new ArrayList>(map.entrySet());
Collections.sort(list, new Comparator>() {
@Override
public int compare(Entry o1,
Entry o2) {
if(o2.getValue().compareTo(o1.getValue())>0){
return 1;
}else if(o2.getValue().compareTo(o1.getValue())<0){
return -1;
} else {
return 0;
}
}
});
for(int i=0;i 解法2（成功，22ms，较快）
对value，放入treemap中排序，
public List topKFrequent(int[] nums, int k) {
List result=new ArrayList<>();
int length=nums.length;
if(length==0||k==0){
return result;
}
// key为数字，value为数字出现的个数
HashMap map=new HashMap<>();
for(int i=0;i> treeMap=new TreeMap<>();
for(Integer now:map.keySet()){
Integer num=map.get(now);
if(treeMap.containsKey(num)){
List list=treeMap.get(num);
list.add(now);
}else{
List list=new ArrayList<>();
list.add(now);
treeMap.put(num, list);
}
}
for(Integer num:treeMap.descendingMap().keySet()){
List list=treeMap.get(num);
for(int i=0;i 解法3（别人的）
最小堆，对values，使用最小堆排序，对于 k 频率之后的元素不用再去处理，进一步优化时间复杂度。
借助 哈希表 来建立数字和其出现次数的映射，遍历一遍数组统计元素的频率
维护一个元素数目为 k的最小堆
每次都将新的元素与堆顶元素（堆中频率最小的元素）进行比较
如果新的元素的频率比堆顶端的元素大，则弹出堆顶端的元素，将新的元素添加进堆中
最终，堆中的 k个元素即为前 k个高频元素
class Solution {
public List topKFrequent(int[] nums, int k) {
// 使用字典，统计每个元素出现的次数，元素为键，元素出现的次数为值
HashMap map = new HashMap();
for(int num : nums){
if (map.containsKey(num)) {
map.put(num, map.get(num) + 1);
} else {
map.put(num, 1);
}
}
// 遍历map，用最小堆保存频率最大的k个元素
PriorityQueue pq = new PriorityQueue<>(new Comparator() {
@Override
public int compare(Integer a, Integer b) {
return map.get(a) - map.get(b);
}
});
for (Integer key : map.keySet()) {
if (pq.size() < k) {
pq.add(key);
} else if (map.get(key) > map.get(pq.peek())) {
pq.remove();
pq.add(key);
}
}
// 取出最小堆中的元素
List res = new ArrayList<>();
while (!pq.isEmpty()) {
res.add(pq.remove());
}
return res;
}
}
解法4（别人的）
对values计数排序
//基于桶排序求解「前 K 个高频元素」
class Solution {
public List topKFrequent(int[] nums, int k) {
List res = new ArrayList();
// 使用字典，统计每个元素出现的次数，元素为键，元素出现的次数为值
HashMap map = new HashMap();
for(int num : nums){
if (map.containsKey(num)) {
map.put(num, map.get(num) + 1);
} else {
map.put(num, 1);
}
}
//桶排序
//将频率作为数组下标，对于出现频率不同的数字集合，存入对应的数组下标
List[] list = new List[nums.length+1];
for(int key : map.keySet()){
// 获取出现的次数作为下标
int i = map.get(key);
if(list[i] == null){
list[i] = new ArrayList();
}
list[i].add(key);
}
// 倒序遍历数组获取出现顺序从大到小的排列
for(int i = list.length - 1;i >= 0 && res.size() < k;i--){
if(list[i] == null) continue;
res.addAll(list[i]);
}
return res;
}
}