堆-数组的堆化+优先队列（PriorityQueue）的使用

一、堆

1、什么是堆？

以完全二叉树的形式将元素存储到对应的数组位置上所形成的新数组

2、为什么要将数组变成堆？

当数组中的元素连续多次进行排序时会消耗大量的时间，将数组变成堆后通过堆排序的方式将会消耗更少的时间

二、接口

给堆定义一个接口，用来规范堆里面的方法

1、在获取堆顶元素和删除堆顶元素的方法中，都必须返回堆顶元素，当堆为空时，返回异常对象要比返回null关键字更加安全

定义堆异常类

package com.ffyc.heap;

/**
 * 自定义堆异常 继承RuntimException而不继承Exception的原因是RuntimException在遇到异常时JVM会自动捕捉异常异常，而Exception必须使用try catch或者throws手动处理异常
 */
public class HeapException extends RuntimeException{
    public HeapException(String message) {
        super(message);
    }
}

三、数组的堆化

这里的时间复杂度是将堆作为满二叉树计算出来的

1、方法一：逐个添加元素创建堆

（1）堆的高度为h，进行上浮和下沉操作最大时间与高度h有关，时间复杂度为

（2）堆是一棵完全二叉树，完全二叉树的时间复杂度与结点有关，为，此处n为二叉树的结点数目

（3）对堆中一个数据进行上浮和下沉操作的时间复杂度均为

（4）通过逐个添加元素创建堆的方式来创建堆的时间复杂度为

2、方法二：将外界数组调整成堆（堆化）

使用逐个添加元素的方式创建堆可能会出现索引越界的问题，为了解决索引越界的问题，我们可以采用动态数组扩容的方式，但是由于不知道到底数组大小要扩到什么程度，因此会损失一部分时间和空间，降低了程序运行效率。如果我们直接将外界传进来的数组调整成堆，即对数组进行堆化，这将会避免由于数组容量不足所带来的索引越界问题

1、使用Integer.MAX_VALUE创建数组

/**
         * 运行程序会报异常java.lang.OutOfMemoryError，表明在JVM中创建的数组大小超出了JVM配置的最大限制，
         * 即JVM的堆空间（Heap space）不足以容纳下这个数组
         */
        int[]a=new int[Integer.MAX_VALUE];

2、heapify（堆化）的平均时间复杂度=每层结点数*移动数=

四、优先队列-PriorityQueue

1、PriorityQueue底层默认使用最小堆实现的

public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

2、PriorityQueue底层提供的将最小堆实现优先队列转为最大堆实现优先队列的方法

public PriorityQueue(Comparator<? super E> comparator) {
        this(DEFAULT_INITIAL_CAPACITY, comparator);
    }

3、PriorityQueue底层提供的将外界传入的集合直接进行堆化的方法

 public PriorityQueue(Collection<? extends E> c) {
        if (c instanceof SortedSet<?>) {
            SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
            this.comparator = (Comparator<? super E>) ss.comparator();
            initElementsFromCollection(ss);
        }
        else if (c instanceof PriorityQueue<?>) {
            PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
            this.comparator = (Comparator<? super E>) pq.comparator();
            initFromPriorityQueue(pq);
        }
        else {
            this.comparator = null;
            initFromCollection(c);
        }
    }

 4、PriorityQueue底层提供的将外界传入的集合进行堆化的方法

public boolean addAll(Collection<? extends E> c) {
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

5、集合堆化的三种形式

（1）创建最小堆，调用addAll方法堆化集合

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(9);
        list.add(2);
        list.add(5);
        list.add(8);
        list.add(3);
        // 创建最小堆，调用addAll方法堆化集合
        PriorityQueue<Integer>priorityQueue=new PriorityQueue<>();
        // 将list集合进行堆化
        priorityQueue.addAll(list);
        // 获取堆顶元素
        System.out.println(priorityQueue.peek());
        // 删除堆顶元素
        priorityQueue.poll();
        System.out.println(priorityQueue.peek());
    }

（2） 创建最小堆，直接堆化集合

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(9);
        list.add(2);
        list.add(5);
        list.add(8);
        list.add(3);
        // 创建最小堆,直接堆化集合
        PriorityQueue<Integer>priorityQueue=new PriorityQueue<>(list);
        // 获取堆顶元素
        System.out.println(priorityQueue.peek());
        // 删除堆顶元素
        priorityQueue.poll();
        System.out.println(priorityQueue.peek());
    }

（3）创建最大堆，调用addAll方法堆化集合

 public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(9);
        list.add(2);
        list.add(5);
        list.add(8);
        list.add(3);
        // 创建底层由最大堆实现的优先队列（使用匿名内部类作为参数，可用idea工具将其转换为lambda）
        PriorityQueue<Integer>priorityQueue=new PriorityQueue<>(Comparator.reverseOrder());
        // 将list集合进行堆化
        priorityQueue.addAll(list);
        // 获取堆顶元素
        System.out.println(priorityQueue.peek());
        // 删除堆顶元素
        priorityQueue.poll();
        System.out.println(priorityQueue.peek());
    }