面试题系列6——堆（topK问题）

目录

题目

1.思路一

代码实现一

时间复杂度一 --->O((N+k)*logN)

2.思路二

代码实现二

时间复杂度分析二  --->O(N*logK)

3.补充：求第k个最大值

代码实现三

4.思考  --->在解决topK的过程中优先级队列比排序的优点

---

题目

设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

题目来源：力扣

题目地址：力扣https://leetcode.cn/problems/smallest-k-lcci/

1.思路一

取前k个最小值，可以将这个数组，依次入优先级队列，然后依次出k次堆

代码实现一

public class topK {
    /**
     * topK问题
     * 方法1：常规解法
     * 求前k个最小值
     * 建立优先级队列，将数组元素依次入堆，再依次出堆k次
     *  //时间复杂度：O((N+k)*logN)
     */
    public int[] smallestK(int[] arr, int k) {
        int[] ret = new int[k];
        if(arr == null || k == 0){
            return ret;
        }


        //O(NlogN)
        Queue<Integer> minHeap = new PriorityQueue<>(arr.length);
        for(int x : arr){
            minHeap.offer(x);
        }
        //O(k*logN)
        for(int i = 0; i < k; i++){

            ret[i] = minHeap.poll();
        }
        return ret;
    }
}

时间复杂度一 --->O((N+k)*logN)

---

2.思路二

1. 取前k个元素建立大根堆        

        这里涉及到如何创建大根堆的问题         

        1.1 priorityQueue默认创建的小根堆          

        1.2 通过传入一个比较器进行创建大根堆           

        1.3 源码是孩子节点小于父亲节点进行交换，这里改成大于父亲节点进行交换.          

        1.4 要想满足大于父亲节点进行交换，就要将integer的compare方法进行相反操作    

2. 将数组剩余元素与堆顶元素进行比较，比对顶元素小，就将对顶元素进行出堆，将该元素进行入堆操作    

3. 遍历堆取前k个值     * 4.要想求第k个最小值，就返回堆顶元素即可 * 时间复杂度：O(N*logK)

代码实现二

1.自定义比较器

package heap;

import java.util.Comparator;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: YAO
 * Date: 2023-03-27
 * Time: 11:24
 */
public class inComparator implements Comparator<Integer> {
    //整形比较器
    @Override
    public int compare(Integer o1, Integer o2){
        return o2.compareTo(o1);
    }
}

2.进行获取前k个最小值 

public class topK{
    public static int[] smallestK2(int[] arr, int k) {
        int[] ret = new int[k];
        if(arr == null || k == 0){
            return ret;
        }
        //O(NlogN)
        inComparator inComparator = new inComparator();
        Queue<Integer> maxHeap = new PriorityQueue<>(inComparator);
        // 2.遍历数组的前k个放在堆中
        //时间复杂度：O(k*logK)
        for (int i = 0; i < k; i++) {
            maxHeap.offer(arr[i]);
        }
        for (int i = k; i <arr.length ; i++) {
            // 3.1如果比堆顶元素小，进行删除堆顶元素，该元素入堆
            if (arr[i] < maxHeap.peek()){
                maxHeap.poll();
                maxHeap.offer(arr[i]);
            }
            // 3.1如果大于堆定元素，往后遍历
        }
        for (int i = 0; i < k; i++) {
            ret[i] = maxHeap.poll();
        }
        return ret;
    }
}

时间复杂度分析二  --->O(N*logK)

---

3.补充：求第k个最大值

直接返回优先级序列的堆顶元素即可

代码实现三

public class topK{
    /**
     * 第k个最大元素
     * 最小根堆的堆顶元素
     */
    public static int MaxK(int[] arr, int k) {
        int[] ret = new int[k];
        if(arr == null || k == 0){
            return -1;
        }
        // 1.建立一个堆大小为k的小根堆
        Queue<Integer> minHeap = new PriorityQueue<>(k);

        // 2.遍历数组的前k个放在堆中
        //时间复杂度：O(k*logK)
        for (int i = 0; i < k; i++) {
            minHeap.offer(arr[i]);
        }

        //时间复杂度：O((N-k)*logK)
        // 3.遍历剩下的arr.length-k个元素，每次都与堆顶元素进行比较，
        for (int i = k; i <arr.length ; i++) {
            // 3.1如果比堆顶元素大，进行删除堆顶元素，该元素入堆
            if (arr[k] > minHeap.peek()){
                minHeap.poll();
                minHeap.offer(arr[i]);
            }
            // 3.1如果小于堆定元素，往后遍历
        }
        return minHeap.peek();
    }
}

4.思考  --->在解决topK的过程中优先级队列比排序的优点

TOP-K问题：即求数据集合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都
不能一下子全部加载到内存中)。

最佳的方式就是用堆来解决，基本思路如下：
        1. 用数据集合中前K个元素来建堆
                前k个最大的元素，则建小堆
                前k个最小的元素，则建大堆
        2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。