优先级队列（堆实现）

优先级队列
概念
一般来说我们会根据事情的重要程度优先处理某事，比如完成学习任务和刷微博，我们会认为完成学习任务比较重要，因此会先执行它，因此在这种情况下，数据结构就应提供两个基本的操作，一是返回最高优先级对象，二是添加新的对象，这种数据结构就叫做优先级队列。
二叉树的顺序存储
存储方式
使用数组保存二叉树结构，即利用层序遍历方式放入数组中。
一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。
而这种表示方法一般的用法就是堆的表示。
堆
堆的概念：

• 堆在逻辑上是一颗完全二叉树
• 堆在物理上保存在数组中
• 满足任意节点的值都大于其子树中节点的值叫做大顶堆
• 满足任意节点的值都小于其子树中结点的值叫做小顶堆
• 堆的基本作用是寻找集合中的最值

顺序存储时的下标关系
已知父结点(parent)的下标，则

• 左孩子节点下标为 parent * 2 + 1;
• 右孩子节点下标为 parent * 2 + 2;

已知孩子节点的下标，则

• 父结点的下标为 (child - 1) / 2;

堆的向下调整
前提：左右子树必须已经是一个堆才能调整
此操作常用于优先队列的出队操作后的排序
以大顶堆为例：

• array 代表进行操作的堆
• size 代表堆节点的个数
• index 代表操作的节点

public void shiftDown(int[] array,int size,int index) {
        //记录父节点位置
        int parent = index;
        //计算左子树的位置
        int child = index * 2 + 1;
        //当子树下标超过或等于数组长度时即为操作结束
        while(child < size) {
            //首先比较左子树和右子树谁的值比较大，如果右子树存在并且右子树的值大于左子树则替换child
            if(child + 1 < size && array[child + 1] > array[child]) {
                child = child + 1;
            }
            //然后比较子树和父结点谁的值较大，如果子树的值大则将父节点的值和子树节点的值交换
            if(array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
            //由于比较此父结点之前，其左子树和右子树都已满足堆的性质（大顶堆就是任意节点的值都要大于其子树中节点的值
            // 小顶堆是任意节点的值都要小于其左右子树节点的值），所以如果此时父结点的值比其左右节点的值都要大则不用向下比较
            }else {
                break;
            }
            //如果父结点的值比子树的值小，则完成交换后还要进行更新，并进行循环以确保交换后子树满足堆的性质
            parent = child;
            child = parent * 2 + 1;
        }
    }

堆的向上调整
此操作常用于优先级队列的插入完成后的排序 （每次只能从一侧向上调整）

public void shiftUp(int[] array, int size, int index) {
        //记录子树的位置
        int child = index;
        //找到父节点的位置
        int parent = (child - 1) / 2;
        //由于是向上调整，子树可能会因为更新而寻找到根结点
        while(child > 0) {
            //此时不需要再进行左右子树值的比较，因为一般用于插入操作，所以只需对新增节点进行判断，而之前的节点已经排好序
            //只比较父结点和当前子树的值
            if(array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
            }else {
                 break;
            }
            child = parent;
            parent = (child - 1) / 2;
        }
    }

利用堆实现优先级队列
实现插入、删除、判空等基本操作

public class MyPriorityQueue {
    //暂不考虑扩容
    int[] array = new int[100];
    int size = 0;

    //插入方法
    public void offer(int x) {
        array[size++] = x;
        shiftUp(array,size,size-1);
    }

    //出队首元素
    public Integer poll() {
        //如果优先队列为空直接返回null
        if(this.size == 0) {
            return null;
        }
        //先记录队首元素
        int ret = this.array[0];
        //让队尾元素替代队首元素，避免损坏堆的结构
        this.array[0] = this.array[size-1];
        size--;
        //已用空间--
        //调整一遍堆
        shiftDown(this.array,this.size,0);
        //返回原队首元素
        return ret;
    }
    //判空
    public boolean isEmpty() {
        if(size == 0) {
            return true;
        }
        return false;
    }
    //此方法是用来将一个不是堆的完全二叉树构造成堆
    public void creatHeap(int[] newArray) {
        //newArray.length - 1得到了最后一个节点的下标
        //然后再 -1 / 2 就是根据最后一个节点的下标找到其父结点的下标
        for(int i = (newArray.length - 1 - 1) / 2; i >= 0; i--) {
            //从最后一个非叶子节点开始进行排序，依次网上排序，保证循环到根节点时，其左子树右子树都满足堆的性质
            shiftDown(array,size,i);
        }
    }
    public void shiftDown(int[] array, int size, int index) {
        //记录父节点位置
        int parent = index;
        //计算左子树的位置
        int child = index * 2 + 1;
        //当子树下标超过或等于数组长度时即为操作结束
        while(child < size) {
            //首先比较左子树和右子树谁的值比较大，如果右子树存在并且右子树的值大于左子树则替换child
            if(child + 1 < size && array[child + 1] > array[child]) {
                child = child + 1;
            }
            //然后比较子树和父结点谁的值较大，如果子树的值大则将父节点的值和子树的值交换
            if(array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
            //由于比较此父结点之前，其左子树和右子树都已满足堆的性质（大顶堆就是任意节点的值都要大于其子树的值
            // 小顶堆是任意节点的值都要小于其左右子树的值），所以如果此时父结点的值比其左右子树的值都要大则不用向下比较
            }else {
                break;
            }
            //如果父结点的值比子树的值小，则完成交换后还要进行更新，并进行循环以确保交换后子树满足堆的性质
            parent = child;
            child = parent * 2 + 1;
        }
    }

    public void shiftUp(int[] array, int size, int index) {
        //记录子树的位置
        int child = index;
        //找到父节点的位置
        int parent = (child - 1) / 2;
        //由于是向上调整，子树可能会因为更新而寻找到根结点
        while(child > 0) {
            //此时不需要再进行左右子树值的比较，因为一般用于插入操作，所以只需对新增节点进行判断，而之前的节点已经排好序
            //只比较父结点和当前子树的值
            if(array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
            }else {
                break;
            }
            child = parent;
            parent = (child - 1) / 2;
        }
    }
}