算法总结-堆（正在更新）

参考：https://mp.weixin.qq.com/s/IjY6BZvcElt7shSv_PjOMQ

简述

堆(Heap)是一种重要的数据结构，是实现优先队列(Priority Queues)首选的数据结构，
作为一种常见的抽象数据类型，在工作、面试、以及算法中常常使用，下面一起来看看吧：

实例解析

题目1：数组中的第 K 个最大元素

题目描述：给在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
示例：
示例 1：输入: [3,2,1,5,6,4] 和 k = 2 ；输出: 5
示例 2：输入: [3,2,3,1,2,4,5,5,6] 和 k = 4；输出: 4

方法1（排序）

对数组进行降序排序, 取下标为k - 1的数组元素即可。

方法2（堆）

使用一个大根堆， 维护一个元素个数为k的最大堆, 将所有数字放入到最大堆中, 全部放完之后, 最大堆中最小的那个元素就是第k个最大的元素。

public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        for (int i = 0; i < nums.length; i++) {
            if (i < k || nums[i] > queue.peek()) {
                queue.offer(nums[i]);
            }
            if (queue.size() > k) {
                queue.poll();
            }
        }
        return queue.peek();
    }

方法3（快排）

利用快速排序中的partition思想解决，时间复杂度O(N)

public int findKthLargest(int[] nums, int k) {
    return partition(nums, 0, nums.length - 1, k - 1);
}

private int partition(int[] nums, int lo, int hi, int k) {
    if (lo == hi) return nums[lo];
    swap(nums, lo, new Random().nextInt(hi - lo + 1) + lo);
    int less = lo, more = hi + 1;
    int i = lo + 1;
    while (i < more) {
        if (nums[i] > nums[lo])
            swap(nums, ++less, i++);
        else if (nums[i] == nums[lo])
            i++;
        else
            swap(nums, --more, i);
    }
    swap(nums, lo, less--);
    if (k > less && k < more){
        return nums[less+1];
    }else if (k <= less){
        return partition(nums, lo, less, k);
    }else {
        return partition(nums, more, hi, k);
    }
}

private void swap(int[] nums, int i, int j) {
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}

题目2：有序矩阵中第K小的元素

题目描述：给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。 请注意，它是排序后的第k小元素，而不是第k个元素。
示例：
matrix = [
[ 1, 5, 9],
[10, 11, 13],
[12, 13, 15]
],
k = 8,

返回 13。

方法1：利用二分查找

public int kthSmallest(int[][] matrix, int k) {
        int lo = matrix[0][0], hi = matrix[matrix.length - 1][matrix[0].length - 1] + 1;//[lo, hi)
        while(lo < hi) {
            int mid = lo + (hi - lo) / 2;
            int count = 0,  j = matrix[0].length - 1;
            for(int i = 0; i < matrix.length; i++) {
                while(j >= 0 && matrix[i][j] > mid) j--;
                count += (j + 1);
            }
            if(count < k) lo = mid + 1;
            else hi = mid;
        }
        return lo;
    }

方法2：利用堆结构实现

public int kthSmallest(int[][] matrix, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(((o1, o2) -> {
            if(o1 - o2 > 0){
                return -1;
            }else if(o1 - o2 < 0){
                return 1;
            }
            return 0;
        }));
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if(pq.size() < k){
                    pq.add(matrix[i][j]);
                }else if(matrix[i][j] < pq.peek()){
                    pq.remove();
                    pq.add(matrix[i][j]);
                }
            }
        }
        return pq.remove();
    }