力扣技巧-堆

1.堆的实现（java）

1.1 最大堆

PriorityQueue<Integer> pq = new PriorityQueue<>(k, (o1, o2) -> o2 - o1);

1.2 最小堆（Java默认）

PriorityQueue<Integer> pq = new PriorityQueue<>(k);

2.前k大，第k大问题（推荐用最小堆解决）

3.前k小，第k小问题（推荐用最大堆解决）

剑指 Offer 40. 最小的k个数

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {

        if (null == arr || k <= 0) {
            return new int[0];
        }

        final int n = arr.length;
        Queue<Integer> pq = new PriorityQueue<>(k, (o1, o2) -> (o2 - o1));

        for (int i = 0; i < n; i ++) {

            if (pq.size() < k) {
                pq.add(arr[i]);
                continue;
            }

            if (pq.peek() > arr[i]) {
                pq.poll();
                pq.add(arr[i]);
            }
        }

        int[] res = new int[k];
        for (int i = 0; i < k; i ++) {
            res[i] = pq.poll();
        }

        return res;
    }
}

347. 前 K 个高频元素

class Solution {

    private class Element {

        public Integer value;
        public Integer number;

        public Element(Integer value, Integer number) {
            this.value = value;
            this.number = number;
        }
    }

    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        Queue<Element> pq = new PriorityQueue<>(k, (e1, e2) ->(e1.number - e2.number));
        for (Integer key : map.keySet()) {
            Element e = new Element(key, map.get(key));
            if (pq.size() < k) {
                pq.add(e);
                continue;
            }

            if (e.number > pq.peek().number) {
                pq.poll();
                pq.add(e);
            }
        }

        int[] res = new int[k];
        for (int i = 0; i < k; i ++) {
            res[i] = pq.poll().value;
        }

        return res;
    }
}

692. 前K个高频单词

class Solution {

    private class Element {

        public String word;
        public Integer number;

        public Element(String word, Integer number) {
            this.word = word;
            this.number = number;
        }
    }

    public List<String> topKFrequent(String[] words, int k) {
        Map<String, Integer> map = new HashMap<>();
        for (String str : words) {
            map.put(str, map.getOrDefault(str, 0) + 1);
        }

        Queue<Element> pq = new PriorityQueue<>((e1, e2) -> {
                if (e1.number != e2.number) {
                    return e1.number - e2.number;
                } else {
                    return e2.word.compareTo(e1.word);
                }
        });

        for (String str : map.keySet()) {
            Element e = new Element(str, map.get(str));

            if (pq.size() < k) {
                pq.add(e);
                continue;
            }

            if (pq.peek().number <= e.number) { 
                pq.add(e);
                pq.poll();
            }
        }

        List<String> res = new ArrayList<>();
        for (int i = 0; i < k; i ++) {
            res.add(pq.poll().word);
        }
        Collections.reverse(res);
        return res;
    }
}

973. 最接近原点的 K 个点

class Solution {
    public int[][] kClosest(int[][] points, int k) {
        int n = points.length;

        Queue<Element> pq = new PriorityQueue<>(k, (e1, e2) -> (int)(e2.len - e1.len));

        for (int[] point : points) {
            Double len = Math.pow(point[0], 2) + Math.pow(point[1], 2);
            Element e = new Element(point, len);

            if (pq.size() < k) {
                pq.add(e);
                continue;
            }

            if (pq.peek().len > len) {
                pq.poll();
                pq.add(e);
            } 
        }

        int[][] res = new int[k][2];
        for (int i = 0; i < k; i ++) {
            res[i] = pq.poll().point;
        }

        return res;
    }

    private class Element {
        private int[] point;
        private Double len;

        private Element(int[] point, Double len) {
            this.point = point;
            this.len = len;
        }
    }
}

23. 合并K个升序链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        final int n = (null == lists ? 0 : lists.length);
        Queue<ListNode> queue = new PriorityQueue<>((v1, v2) -> v1.val - v2.val);

        for (int i = 0; i < n; i ++) {
            ListNode node = lists[i];
            if (null != node) {
                queue.add(node);
            }
        }

        ListNode dummy = new ListNode();
        ListNode tail = dummy;

        while (!queue.isEmpty()) {

            ListNode curNode = queue.poll();
            tail.next = curNode;
            tail = tail.next;
            if (null != curNode.next) {
                queue.add(curNode.next);
            }
        }

        tail.next = null;

        return dummy.next;
    }
}

373. 查找和最小的 K 对数字

class Solution {

    private class Element {

        public List<Integer> list;
        public int sum;

        public Element(List<Integer> list, int sum) {
            this.list = list;
            this.sum = sum;
        }
    }

    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        Queue<Element> pq = new PriorityQueue<>(k, (e1, e2) -> (e2.sum - e1.sum));

        for (int i = 0; i < nums1.length; i ++) {
            for (int j = 0; j < nums2.length; j ++) {

                List<Integer> list = new ArrayList<>();
                list.add(nums1[i]);
                list.add(nums2[j]);
                int sum = nums1[i] + nums2[j];
                Element e = new Element(list, sum);

                if (pq.size() < k) {
                    pq.add(e);
                    continue;
                }

                if (pq.peek().sum > e.sum) {
                    pq.poll();
                    pq.add(e);
                } else {
                    break;
                }
            }
        }

        List<List<Integer>> res = new ArrayList<>(k);
        while (!pq.isEmpty()) {
            res.add(pq.poll().list);
        }

        return res;
    }
}