【LeetCode】347.前 K 个高频元素

今日学习的文章链接和视频链接

leetcode题目地址：347.前 K 个高频元素

 代码随想录题解地址：代码随想录

题目简介

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

看到题目的第一想法(可以贴代码）

1. 想不到怎么使用stack和queue来解决该问题，采用的是直线思维。

先对数组排序，再遍历数组，用hashmap才存储元素值（key）和元素出现的次数（value），然后对hashmap的valueSet进行降序排序，再取前k个元素，作为result。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //只有一个元素的情况
        if(nums.length == 1) return nums;

        //存储最终结果
        int[] res = new int[k];

        //先对原始数组进行排序
        Arrays.sort(nums);

        //存储数字和他们出现的频率
        HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();

        int temp = nums[0];
        int count = 1;
        for(int i = 1; i < nums.length; i++){
            //如果和上一个数一致，则该数出现次数+1
            if(nums[i] == temp){
                count++;
            }else{
                //如果和上一个数不同，则识别为另一个数字的开头
                hm.put(temp,count);
                temp = nums[i];
                count = 1;
            }
            //判定是否到末尾，需要回收末尾（末尾只剩一个数 or 末尾连续几个数都一样 时，都只需要put就行）
            if(i == nums.length - 1){
                hm.put(temp,count);
            }
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(hm.entrySet());

        // 使用Collections.sort()排序，按value，即按出现次数进行排序
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o2.getValue().compareTo(o1.getValue());
            }
        });
        
        // for-each循环, 获得排序后的结果
        int index = 0;
        for (Map.Entry<Integer, Integer> mapping : list){
            //System.out.println(mapping.getKey() + ":" + mapping.getValue());
            //判定是否已获取k个最高频数字
            if(index != k){
                res[index++] = mapping.getKey();
            }else{
                break;
            }
        }
        return res;
    }
}

实现过程中遇到哪些困难

1. 想不到怎么使用stack和queue来解决该问题

看完代码随想录之后的想法

【解题思路】和我的基本一致，但在对“元素出现频率”进行排序时，我用的是普通排序时间复杂度为n*log(n)，答案采用小顶堆排序，时间复杂度为n*log(k)

【想法】无

标准答案

class Solution {
    //解法2：基于小顶堆实现
    public int[] topKFrequent2(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){//小顶堆只需要维持k个元素有序
            if(pq.size()<k){//小顶堆元素个数小于k个时直接加
                pq.add(new int[]{entry.getKey(),entry.getValue()});
            }else{
                if(entry.getValue()>pq.peek()[1]){//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                    pq.poll();//弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
                    pq.add(new int[]{entry.getKey(),entry.getValue()});
                }
            }
        }
        int[] ans = new int[k];
        for(int i=k-1;i>=0;i--){//依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
}

学习时长

略

---

今日收获

1. 使用Collections.sort()排序，按value排序

List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(hm.entrySet());

// 使用Collections.sort()排序，按value排序
Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
     @Override
     public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
        return o2.getValue().compareTo(o1.getValue());
     }
});
        
// for-each循环
int index = 0;
for (Map.Entry<Integer, Integer> mapping : list){
     System.out.println(mapping.getKey() + ":" + mapping.getValue());
     if(index != k){
         res[index++] = mapping.getKey();
     }else{
         break;
     }
}

2. PriorityQueue小顶堆

PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>(); //小顶堆，默认容量为11
PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(11,new Comparator<Integer>(){ //大顶堆，容量11
    @Override
    public int compare(Integer i1,Integer i2){
        return i2-i1;
    }
});

ps: add自动维持顶部为最小的值。 

3. HashMap获取key序列或value序列

        HashMap<String, Integer> map = new HashMap<String, Integer>();
		map.put("Kobe", 1);
		map.put("Jordan", 2);
		map.put("James", 3);
		
		//通过keySet()获取key，再通过map.get(key)获取value
		Set<String> set = map.keySet();
		for(String str : set) {
			System.out.println(str + " " + map.get(str));
		}
		System.out.println( "------------" );
		
		//通过map.entrySet()获得键值对，性能较高
		Set<Entry<String, Integer>> en = map.entrySet();
		for(Entry<String, Integer> entry : en) {
			System.out.println(entry.getKey() + " " + entry.getValue());
		}
		System.out.println( "------------" );
		
		//通过values()取值
		Collection<Integer> values = map.values();
		for(Integer i : values)
			System.out.println(i);	


//上面似乎有bug
//-------------------------------------------------------------


        // 1. 使用 Iterator 遍历 EntrySet
        Iterator < Entry < Integer, String >> iterator = coursesMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry < Integer, String > entry = iterator.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

        // 2. 使用 Iterator 遍历 HashMap KeySet
        Iterator < Integer > iterator = coursesMap.keySet().iterator();
        while (iterator.hasNext()) {
            Integer key = iterator.next();
            System.out.println(key);
            System.out.println(coursesMap.get(key));
        }

        // 3. 使用 For-each 循环遍历 HashMap
        for (Map.Entry < Integer, String > entry: coursesMap.entrySet()) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

        // 4. 使用 Lambda 表达式遍历 HashMap
        coursesMap.forEach((key, value) -> {
            System.out.println(key);
            System.out.println(value);
        });