优先级队列(堆)

1.1 概念

        队列是一种先进先出(FIFO) 的数据结构 ，但有些情况下， 操作的数据可能带有优先级，一般出队 列时，可能需要优先级高的元素先出队列 ，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话；初中那会班主任排座位时可能会让成绩好的同学先挑座位。

        在这种情况下，数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象 。这种数据结构就是优先级队列

2. 优先级队列的模拟实现

JDK1.8 中的 PriorityQueue 底层使用了堆这种数据结构 ，而堆实际就是在完全二叉树的基础上进行了一些调整。

2.1 堆的概念

如果有一个 关键码的集合 K = {k0 ， k1 ， k2 ， … ， kn-1} ，把它的所有元素 按完全二叉树的顺序存储方式存储 在一 个一维数组中 ，并满足： Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0 ， 1 ， 2… ，则 称为 小堆 ( 或大堆) 。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质：

        堆中某个节点的值总是不大于或不小于其父节点的值；

        堆总是一棵完全二叉树

图解：

 对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低

将元素存储到数组中后，可以根据二叉树章节的性质 5 对树进行还原。假设 i 为节点在数组中的下标，则有：

如果 i 为 0 ，则 i 表示的节点为根节点，否则 i 节点的双亲节点为 (i - 1)/2

如果 2 * i + 1 小于节点个数，则节点 i 的左孩子下标为 2 * i + 1 ，否则没有左孩子

如果 2 * i + 2 小于节点个数，则节点 i 的右孩子下标为 2 * i + 2 ，否则没有右孩子

图解：

2.3 堆的创建

2.3.1 堆向下调整

向下过程 ( 以小堆为例 ) ：

        1. 让 parent 标记需要调整的节点， child 标记 parent 的左孩子 ( 注意： parent 如果有孩子一定先是有左孩子 )

        2. 如果 parent 的左孩子存在，即 :child < size ， 进行以下操作，直到 parent 的左孩子不存在

parent 右孩子是否存在，存在找到左右孩子中最小的孩子，让 child 进行标

将 parent 与较小的孩子 child 比较，如果：

parent小于较小的孩子child ，调整结束

        否则：交换parent 与较小的孩子 child ，交换完成之后， parent 中大的元素向下移动，可能导致子 树不满足对的性质，因此需要继续向下调整，即parent = child ； child = parent*2+1; 然后继续 2

图解：

代码实现：

public class TestHeap {

    public int[] elem;
    public int usedSize;

    public TestHeap(){
        this.elem = new int[10];
    }
    //放入数据
    public void initElem(int array[]){
        for (int i = 0; i < elem.length; i++) {
            elem[i] = array[i];
            usedSize++;
        }
    }
    //构建堆
    public void createHeap(){
        for (int parent = (usedSize - 1 - 1) / 2; parent >= 0 ; parent--) {
            shiftDown(parent,usedSize);
        }
    }
    //实现小根堆
    public void shiftDown(int parent,int len){
        int child = 2 * parent + 1;
        while(child < len) {
            if (child + 1 < len && elem[child] > elem[child + 1]) {
                child++;
            }
            if(elem[child] > elem[parent]){
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                parent = child;
                child = 2 * parent + 1;
            }else{
                break;
            }
        }
    }

初始数据：

 创建为小根堆

2.4.2 堆的删除

注意：堆的删除一定删除的是堆顶元素。 具体如下：

1. 将堆顶元素对堆中最后一个元素交换

2. 将堆中有效数据个数减少一个

3. 对堆顶元素进行向下调整

图解：

代码实现：

public void pollHeap() {
        if(isEmpty()){
            return;
        }
        //交换
        swap(elem,0,usedSize-2);
        usedSize--;
        //删除后,重新排序
        shiftDown(0,usedSize);
    }
    //交换栈顶和队尾元素
    private void swap(int[]array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

1. PriorityQueue 中插入对象

        优先级队列在插入元素时有个要求：插入的元素不能是null 或者元素之间必须要能够

进行比较

        但是很多对象不能直接比较，我们一般会使用equal方法，但是，也会有很多缺点

        对于用户实现自定义类型，都默认继承自Object 类，而 Object 类中提供了 equal 方法，而 == 默认情况下调 用的就是 equal 方法 ，但是该方法的比较规则是： 没有比较引用变量引用对象的内容，而是直接比较引用变量的地 址 ，但有些情况下该种比较就不符合题意。

        这时候我们就有三种方法解决这个问题

3.1 覆写基类的 equals

在定义的类中使用Generate覆写

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

3.2 基于Comparble接口类的比较

Comparble 是 JDK 提供的泛型的比较接口类

        对用用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现 Comparble 接口即可，然后在类 中重写 compareTo 方法。

public interface Comparable<E> {
// 返回值:
// < 0: 表示 this 指向的对象小于 o 指向的对象
// == 0: 表示 this 指向的对象等于 o 指向的对象
// > 0: 表示 this 指向的对象大于 o 指向的对象
int compareTo(E o);
}

class Student implements Comparable<Student>{
    public String name;

    public int age;

    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
public int compareTo(Student o) {
        return this.age - o.age;
    }
}

3.3 基于比较器比较

步骤：

         用户自定义比较器类，实现 Comparator 接口

        覆写 Comparator 中的 compare 方法

class NameComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

public class Test {
    public static void main2(String[] args) {
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("zhangsan",10);
        NameComparator nameComparator = new NameComparator();
        System.out.println(nameComparator.compare(student1, student2));
]