347. Elementos de alta frecuencia Top K (implementados en java) --LeetCode

tema:

Dada una matriz de enteros no vacía, devuelve los elementos con la mayor frecuencia de ocurrencia k.

Ejemplo 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

Ejemplo 2:

输入: nums = [1], k = 1
输出: [1]

rápido:

• Puede suponer que el k dado siempre es razonable y que 1 ≤ k ≤ el número de elementos diferentes en la matriz.
• La complejidad temporal de su algoritmo debe ser mejor que O (n log n), donde n es el tamaño de la matriz.
• Los datos de la pregunta aseguran que la respuesta sea única, en otras palabras, el conjunto de los primeros k elementos de alta frecuencia de la matriz es único.
• Puede devolver las respuestas en cualquier orden.

Solución 1: montón

/**
 * 思路：
 * 统计词频在新的map上，k是数，v是词频
 * heap中存放词频，统计前k个
 */
    public int[] topKFrequent(int[] nums, int k) {
    
    
        int[] res=new int[k];
        HashMap<Integer, Integer> map = new HashMap<>();
        PriorityQueue<Integer> heap = new PriorityQueue<>((v1, v2) -> map.get(v2) - map.get(v1));
        for (int i:nums){
    
    
            map.put(i,map.getOrDefault(i, 0)+1);
        }
        for(int key:map.keySet()){
    
    
            heap.add(key);
        }
        for (int i=0;i<k;i++){
    
    
            res[i]=heap.remove();
        }
        return res;
    }

Complejidad del tiempo: Onlogn

Complejidad espacial: activada

Solución 2: árbol de búsqueda binaria

/**
 * 思路：
 * 二叉搜索树
 * 统计词频在新的map上，k是数，v是词频
 * TreeMap中存放，k是词频，v是数的集合
 * 之后获取前k高词频的数
 */
    public int[] topKFrequent(int[] nums, int k) {
    
    
        int[] result = new int[k];
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i:nums){
    
    
            map.put(i,map.getOrDefault(i,0)+1);
        }
        TreeMap<Integer, List<Integer>> bST = new TreeMap<>();
        for (int num:map.keySet()){
    
    
            Integer frequent = map.get(num);
            if (!bST.containsKey(frequent)){
    
    
                bST.put(frequent,new ArrayList());
            }
            bST.get(frequent).add(num);
        }
        List<Integer> list = new ArrayList<>();
        while (list.size()<k){
    
    
            list.addAll(bST.pollLastEntry().getValue());
        }
        for (int i=0;i<k;i++){
    
    
            result[i]= list.get(i);
        }
        return result;
    }

Complejidad de tiempo: activado

Complejidad espacial: activada