Java 数据结构与算法之堆

一、堆

堆是一种基本的数据结构，本质是一棵完全二叉树。

堆分为最大堆和最小堆。堆常用于构建优先队列，堆排序，哈夫曼树/编码等。

• 最大堆：父节点的值比所有子节点的值都要大或者相等
• 最小堆：父节点的值比所有子节点的值都要小或者相等（如下图）

 如上图所示，堆的底层数据结构通常采用数组来存储

1、插入

以最小堆为例，插入后依然保持最小堆的特性，首先针对下面的最小堆，插入数据1

数据1插入到数组尾部，发现比父节点10小，则交换

 交换之后发现数据1依然比父节点的值小，再次交换，直到父节点的值大于等于它

2、删除：删除最大堆的最大值，最小堆的最小值，即堆顶，让剩下的数据继续保持最小最大堆的特性

以上图插入结果为例，删除最小堆的堆顶数值为1的元素

 

 删除后，做了几次交换，依然保持了最小堆特性。

二、优先队列（PriorityQueue）

优先队列是JDK1.5开始提供的API，默认最小堆排序，源码可自行在jdk查看，这里就不多说了。

        // 默认最小堆
        PriorityQueue<Integer>minQ=new PriorityQueue<Integer>();
        minQ.offer(1);
        minQ.offer(13);
        minQ.offer(6);
        while (!minQ.isEmpty()) {
            System.out.println(minQ.poll());
        }
        // 通过比较器 定义最大堆
        PriorityQueue<Integer>maxQ=new PriorityQueue<Integer>((a,b)->b-a);
        maxQ.offer(1);
        maxQ.offer(13);
        maxQ.offer(6);
        while (!maxQ.isEmpty()) {
            System.out.println(maxQ.poll());
        }
        PriorityQueue<Integer>maxQ2=new PriorityQueue<Integer>((a,b)->{return b-a;});
        maxQ2.offer(1);
        maxQ2.offer(13);
        maxQ2.offer(6);
        while (!maxQ2.isEmpty()) {
            System.out.println(maxQ2.poll());
        }
        // 通过比较器，定义集合的排序
        PriorityQueue<Integer>maxQ3=new PriorityQueue<Integer>(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        maxQ3.offer(1);
        maxQ3.offer(13);
        maxQ3.offer(6);
        while (!maxQ3.isEmpty()) {
            System.out.println(maxQ3.poll());
        }
        // 数组比较器
        PriorityQueue<int[]>queue1=new PriorityQueue<int[]>((a,b)->b[0]-a[0]);
        queue1.offer(new int[]{1,4});
        queue1.offer(new int[]{3,2});
        queue1.offer(new int[]{2,8});
        while (!queue1.isEmpty()) {
            int[] tmp=queue1.poll();
            System.out.println(tmp[0]);
            System.out.println(tmp[1]);
        }

• offer 和 add的区别：offer返回布尔值，add失败会抛异常

• Poll 和 remove的区别：poll失败返回null，remove失败会抛异常

• peek 和 element的区别：peek失败返回null，element失败会抛异常

下面是LeetCode的一道题 703. Kth Largest Element in a Stream 的示例

import java.util.PriorityQueue;

// 工具类，求出第K大的数字
public class KthLargest {
    public static void main(String[] args) {
        int k = 3;
        int[] arr = {4, 5, 8, 2};
        KthLargest kthLargest = new KthLargest(3, arr);
        System.out.println(kthLargest.add(3));   // returns 4
        System.out.println(kthLargest.add(5));   // returns 5
        System.out.println(kthLargest.add(10));  // returns 5
        System.out.println(kthLargest.add(9));   // returns 8
        System.out.println(kthLargest.add(4));   // returns 8
    }

    private PriorityQueue<Integer> priorityQueue;
    private int k;

    public KthLargest(int k, int[] nums) {
        this.priorityQueue = new PriorityQueue<Integer>();
        this.k = k;
        for (int i = 0; i < nums.length; i++) {
            priorityQueue.add(nums[i]);
        }
        while (priorityQueue.size() > k) {
            priorityQueue.poll();
        }
    }

    public int add(int val) {
        this.priorityQueue.add(val);
        while (priorityQueue.size() > k) {
            priorityQueue.poll();
        }
        return priorityQueue.peek();
    }
}

优点和用途

• PriorityQueue对比数组插入和删除（O(n)的复杂度）效率更高，复杂度为 O(logn) ，每次插入和删除后依然保持堆特性。
• PriorityQueue数据有序的输出出来
• 哈夫曼编码等，第K个最大最小值