力扣100题解及笔记堆-CSDN博客

本文链接：https://blog.csdn.net/hiahiakk/article/details/142301891

理论基础

堆

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值

最大/小堆

优先级队列内部元素是自动依照元素的权值排列，能够保证快速取出优先级最高的元素，同时插入新元素也能保持堆的有序性。

利用特性，可以快速获取最小（或最大）值，快速定位频率最高或最低的元素。

*统计最大用小顶堆，统计最小用大顶堆

典型问题

任务调度：按照优先级执行任务。
Dijkstra最短路径算法：使用最小堆优化选取最短路径。
Huffman编码：利用最小堆构建最优二叉树。
最小K个数：使用最大堆来保持K个最小元素。
合并K个有序链表：使用最小堆，每次从堆顶取出最小值，然后将取出值的链表的下一个元素加入堆中。
前K个高频元素：利用最小堆存储元素及其频率，找到出现频率最高的K个元素。

维护最大/小堆

维护一个有K个元素的最小堆：
    如果当前堆不满，直接添加
    堆满的时候
        新读到的数小于等于堆顶，过
        新读到的数大于等于堆顶，堆顶拿出，放入新数

将每个元素都插入堆，大小超过 k 时堆顶判断

215.第K大

215. 数组中的第K个最大元素

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

 

示例 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 <= nums.length <= 105
-104 <= nums[i] <= 104

用堆

class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> p=new PriorityQueue<>();
        for(int n:nums){
            p.offer(n);
            if(p.size()>k) p.poll();
        }
        return p.poll();// 剩下的就是前k大的元素了，返回最小的
    }
}

用排序秒解

    public int findKthLargest(int[] nums, int k) {
        Arrays.sort(nums);
        return nums[nums.length - k];
    }

分治思想：快速选择

//快速选择算法
class Solution {
    public int findKthLargest(int[] nums, int k) {
        int p = nums[new Random().nextInt(nums.length)];
        int bigCount = 0, equalCount = 0;       
        // 统计大于、等于基准值的数量，并将小于基准值的元素放入原数组
        for (int num : nums) {
            if (num > p) bigCount++;
            else if (num == p) equalCount++;
        }
        // 第k大元素在大于基准值的部分
        if (k <= bigCount) {
            int[] big = new int[bigCount];
            int idx = 0;
            for (int num : nums)  if (num > p) big[idx++] = num;
            return findKthLargest(big, k);
        }
        // 第k大元素在小于基准值的部分
        if (k > bigCount + equalCount) {
            int[] small = new int[nums.length - bigCount - equalCount];
            int idx = 0;
            for (int num : nums) if (num < p) small[idx++] = num;
            return findKthLargest(small, k - bigCount - equalCount);
        }
        // 第k大元素等于基准值
        return p;
    }
}

347.K高频

347. 前 K 个高频元素

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

 

示例 1:

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

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

提示：

1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的
 

进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map <Integer,Integer> m=new HashMap<>();
        for(int n:nums) m.put(n,m.getOrDefault(n,0)+1);//查一下有几次（没有则0），再加一
        PriorityQueue<int[]> pq=new PriorityQueue<>((a,b)->(a[1]-b[1]));
        m.forEach((n,f)->{
            pq.add(new int[]{n,f});
            if(pq.size()>k) pq.poll();//size是方法
        });
        int[] r=new int[k];
        for(int i=k-1;i>=0;i--) r[i]=pq.poll()[0];//别忘了加0！！第一个元素
        return r;
    }
}

    //[0] 获取数组中的第一个元素，[1]返回第二个元素即频率
    // 不知道返回多少个的时候可以用这个
    // List<Integer> res = new ArrayList<>();
    // while (!pq.isEmpt

295.数据流中位数h

295. 数据流的中位数

中位数是有序整数列表中的中间值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。

例如 arr = [2,3,4] 的中位数是 3 。
例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5 。
实现 MedianFinder 类:

MedianFinder() 初始化 MedianFinder 对象。

void addNum(int num) 将数据流中的整数 num 添加到数据结构中。

double findMedian() 返回到目前为止所有元素的中位数。与实际答案相差 10-5 以内的答案将被接受。

示例 1：

输入
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
输出
[null, null, null, 1.5, null, 2.0]

解释
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1);    // arr = [1]
medianFinder.addNum(2);    // arr = [1, 2]
medianFinder.findMedian(); // 返回 1.5 ((1 + 2) / 2)
medianFinder.addNum(3);    // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0
提示:

-105 <= num <= 105
在调用 findMedian 之前，数据结构中至少有一个元素
最多 5 * 104 次调用 addNum 和 findMedian

小顶堆 A 保存较大的一半

大顶堆 B 保存较小的一半

中位数可仅根据 A,B 的堆顶元素得到

class MedianFinder {
    Queue <Integer> A,B; //注意变量范围
    public MedianFinder() {//初始化 MedianFinder 对象
        A=new PriorityQueue<>();
        B=new PriorityQueue<>((x,y)->(y-x));
    }
    public void addNum(int num) {//将数据流中的整数 num 添加到数据结构中
        //保持两个堆的平衡
        if(A.size()!=B.size()){
            A.add(num);
            B.add(A.poll());
        }else{
            B.add(num);
            A.add(B.poll());
        }

    }
    public double findMedian() {//返回到目前为止所有元素的中位数
        return A.size()!=B.size()?A.peek():(A.peek()+B.peek())/2.0;//size是方法！
    }
}