leetcode刷题之堆

堆

堆

• 堆结构就是 用数组实现的完全二叉树,可以是数组的一部分形成了堆

  • 一般是从0开始到某个下标index形成一个大根堆或者小根堆,堆的大小heapSize=index+1
  • 如果从0下标开始,每个节点i,他的左子节点为:2i + 1,右子节点为:2i + 2, 他的父节点为 (i-1)/2;
  • 排序过程的时间复杂度是O(nlgn)。因为建堆的时间复杂度是O(n)（调用一次）；调整堆的时间复杂度是lgn，调用了n-1次，所以堆排序的时间复杂度是O(nlgn)
  • java中默认是小根堆 使用lamada表达式可以获得大根堆PriorityQueue queue = new PriorityQueue<>((x, y)->y-x);
    queue.offer(0) 入堆 queue.poll() 出堆 queue.peek()堆顶元素
    queue.isEmpty() 是否为空

• 堆实际上就是一个随时能给你最大值的一个数据结构 当你不是想要全部的排序顺序序列的时候可能会有大用途 如top(k)问题

• 堆的难点在于 你怎么用这个给你排好序的 你个结构 你要拿什么进去做排序

数组中的第K个最大元素

    public int findKthLargest(int[] nums, int k) {

		// 建立一个容量为k的小根堆 
		//注意这个题目不能建立length长度的堆  不然时间复杂度就会降为
		//NlogN就失去了 使用小根堆的优化意义了
        PriorityQueue<Integer> qu = new PriorityQueue<>(k,(x,y)->(x-y));
       	//先进k个
        for (int i = 0; i < k; i++) {
            qu.offer(nums[i]);
        }
       //
        for(int i =k;i<nums.length;i++)
        {
            int tmp = nums[i];
            if(qu.peek()<tmp)//进行比较 先出后进
                {
                    qu.poll();
                    qu.offer(tmp);
                }
        }
        return qu.poll();
    }

但是这题最优解法还是
基于快速排序的选择方法

• 由此可以发现每次经过「划分」操作后，我们一定可以确定一个元素的最终位置，即 x 的最终位置为 q，并且保证 a[a[l⋯q−1] 中的每个元素小于等于 a[q]，且 a[q] 小于等于a[q+1⋯r] 中的每个元素。所以只要某次划分的 q为倒数第 k 个下标的时候，我们就已经找到了答案。 我们只关心这一点，至于 a[l⋯q−1] 和 a[q+1⋯r] 是否是有序的，我们不关心
• 对于极端情况下会退化为O(n2) 我们是用 随机选择元素来进行加速
• 时间复杂度是O(n)

前 K 个高频元素

         int res [] = new int [k];
        HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {//将 num 和num出现的次数放到hm中
            if(hm.containsKey(nums[i]))
            {
                hm.put(nums[i],hm.get(nums[i])+1);
            }
            else
                hm.put(nums[i],1);
        }
        System.out.println(hm.size());
        PriorityQueue<Map.Entry<Integer,Integer>> qu = new PriorityQueue<>(hm.size(),(Map.Entry a,Map.Entry b)->(Integer) b.getValue()-(Integer)a.getValue()); // 建立一个大根堆
        Iterator it = hm.entrySet().iterator();
         while(it.hasNext()){//遍历map 放入到大根堆中去
             Map.Entry entry =(Map.Entry) it.next();
             qu.offer(entry);
        }
        for (int i = 0; i < k; i++) { //取前k个 放入到结果中
            res[i] = qu.poll().getKey();

        }
        return res;

    }

有序数组的第k小元素

这个代码写的非常巧妙 妙就秒在 他的

        for (int i = 0; i < n; i++) {
            pq.offer(new int[]{matrix[i][0], i, 0}); 
          //这个数组的设定上面
         //每行的第一个数, 第i行 ,  第i行的第几个数
         //把它放到一起进入 最小堆中间去
        }

    作者：LeetCode-Solution  [代码链接](https://leetcode-cn.com/problems/kth-smallest-element-in-a-sorted-matrix/solution/you-xu-ju-zhen-zhong-di-kxiao-de-yuan-su-by-leetco/)

    public int kthSmallest(int[][] matrix, int k) {
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                return a[0] - b[0];
            }//构建最小堆
        });
        int n = matrix.length;
        for (int i = 0; i < n; i++) {//把每一行第一个数字填进去
            pq.offer(new int[]{matrix[i][0], i, 0});
        }
        for (int i = 0; i < k - 1; i++) {
            int[] now = pq.poll();//输出最小的数 然后按照数组中另外两个数字(行和列)
            //进行  入堆操作  
            if (now[2] != n - 1) {
                pq.offer(new int[]{matrix[now[1]][now[2] + 1], now[1], now[2] + 1});
            }
        }
        return pq.poll()[0];
    }

最后一块石头的重量
有一堆石头，每块石头的重量都是正整数。
每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。

思路就是构建大根堆 每次取两个比较 然后再把取出来的石头剩余放进去 结束条件是size()<2;

数据流的中位数

会议室 II