数据结构——堆

你能学到什么：

• 堆大概的底层实现到底是什么样的。
• 向下调整shiftdown
• 向上调整shiftup

正文

下面我们将手搓一个堆出来。

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
}
public class MyPriorityQueue {
    //使用数组来模拟堆
    private TreeNode[] arr;
    //记录容量
    private int usedSize;

}

堆的概念（优先级队列）

我们知道：堆其实就是优先级队列，很显然，区别于普通的队列二字，他多出了优先级三个字。优先级其实也就是根据某个排序规则划定的一种顺序，此数据结构广泛应用于数据量较大且不适合统一排序的场景。

提供的方法

	public MyPriorityQueue() {
        this.arr = new TreeNode[10];
    }

 //offer 添加元素
    public boolean offer(TreeNode node){
        if(isFull()){
            seDoubleCapacity();
        }
        arr[usedSize++] = node;
        //此时使用尾差 + 向上调整是比较优的,传入的是插入元素所在的下标，也即最后一个位置的下标
        shiftUp();
        return true;
    }
    
    //peek 获取堆顶元素
    public TreeNode peek(){
        if(!isEmpty()){
            return arr[0];
        }
        return null;
    }
    
    //poll 弹出堆顶元素
    public TreeNode poll(){
        if(!isEmpty()){
            //先将堆顶元素保存起来
            TreeNode tmp = arr[0];
            //将最后一个元素直接赋值给堆顶元素
            arr[0] = arr[--usedSize];
            //然后再使用向下调整
            shiftDown();
            return tmp;
        }
        return null;
    }
    
    //isEmpty 判断是否为空
    public boolean isEmpty(){
        if(usedSize==0){
            return true;
        }
        return false;
    }
    
    //isFull 判断是否满了
    public boolean isFull(){
        if(usedSize == arr.length){
            return true;
        }
        return false;
    }
    // size 返回容量
    public int size(){
        return usedSize;
    }
    //setDoubleCapacity
    public void seDoubleCapacity(){
        //注意这里的copyOf 是深拷贝
        arr = Arrays.copyOf(arr,arr.length*2);
    }

建堆

方法的基本框架都写好了，下面就是建堆了。

 public TreeNode[] createHeap(TreeNode[] array){
        for(int i=0;i< array.length;i++){
            //如果在复制的过程中空间不够了，就扩容
            if(isFull()){
                seDoubleCapacity();
            }
            arr[i] = array[i];
            usedSize++;
        }
        //这里就是整个建堆的核心逻辑，莫问为啥减2，这是公式。
        //附有图解，可以参考理解
        for (int parent = (usedSize -2)/2; parent >=0 ; parent--) {
            shiftDown(parent,usedSize);
        }
        return Arrays.copyOf(arr,arr.length);
    }

向下调整

private void shiftDown(int parent, int len) {
        //至少会有一个左孩子,因为：既然（usedSize-2）/2能算出来一个数，那必定会有一个左孩子
        int child = parent*2+1;
        //循环条件：至少有一个左孩子
        while(child < len){
            //如果存在右孩子，找到左右孩子中最大的那一个：
            if(child+1<len && arr[child].val<arr[child+1].val){
                child = child+1;
            }
            //如果最大的那个孩子的值大于父亲节点，就交换
            if(arr[child].val>arr[parent].val){
                int tmp = arr[child].val;
                arr[child].val = arr[parent].val;
                arr[parent].val = tmp;

                //继续向下搜索，看看是否还有能交换的
                parent = child;
                child = parent*2+1;
            }else{
                break;
            }
        }
    }

此时，堆就算是建好了

补充，修改方法里缺失的代码

public TreeNode poll(){
        if(!isEmpty()){
            //先将堆顶元素保存起来
            TreeNode tmp = arr[0];
            //将最后一个元素直接赋值给堆顶元素
            arr[0] = arr[--usedSize];
            //然后再使用向下调整
            shiftDown(0,usedSize);
            return tmp;
        }
        return null;
    }

向上调整

当我们补充offer 代码的时候，会发现一个问题，我们是选择头插还是尾差呢？
你可以想象一下：如果选择了头插，容量不够的时候需要进一步扩容，况且我们使用的是数组模拟堆。如果头插，我们需要整体都向后移动一位，移动后的堆已经不是原来的堆了，此时我们还需要向下调整，光是想想就很麻烦吧。
但是如果是尾插，再结合向上调整，就不会这样：

public boolean offer(TreeNode node){
        if(isFull()){
            seDoubleCapacity();
        }
        arr[usedSize++] = node;
        //此时使用尾差 + 向上调整是比较优的,传入的是插入元素所在的下标，也即最后一个位置的下标
        int child = usedSize-1;
        shiftUp(child);
        return true;
    }

    private void shiftUp(int child) {
        //先计算出父亲节点
        int parent = (child -1)/2;
        //如果parent为0，就说明到达的最后一个节点，即root，循环结束,此处的条件也能改成child>0,灵活多变
        while (parent>=0){
            //由于本来已经是一个大根堆，任意根节点一定大于另一个孩子，所以我们只需要考虑新插入的数据和根节点的关系就行了。
            //不用先找左右孩子哪一个大了。
            if(arr[child].val>arr[parent].val){
                //交换：
                int tmp = arr[child].val;
                arr[child].val = arr[parent].val;
                arr[parent].val = tmp;
                child = parent;
                parent = (child -1)/2;
            }else{
                break;
            }
        }
    }

由于向上调整和向下调整有很相似的逻辑，我就不赘述图了，可以自己尝试画画，加深一下印象。

测试

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}
public class MyPriorityQueue {
    public static void main(String[] args) {
        MyPriorityQueue myPriorityQueue = new MyPriorityQueue();
        myPriorityQueue.offer(new TreeNode(99));
        myPriorityQueue.offer(new TreeNode(23));
        myPriorityQueue.offer(new TreeNode(1));
        myPriorityQueue.offer(new TreeNode(25));
        myPriorityQueue.offer(new TreeNode(6));
        myPriorityQueue.offer(new TreeNode(83));
        myPriorityQueue.offer(new TreeNode(2));
        myPriorityQueue.offer(new TreeNode(33));
        System.out.println("peek出来的值："+myPriorityQueue.peek().val);//99
        System.out.println("poll出来的值："+myPriorityQueue.poll().val);//99
        System.out.println(myPriorityQueue.usedSize);//7
        System.out.println(myPriorityQueue.isEmpty());//false
        System.out.println(myPriorityQueue.isFull());//false
        System.out.println("经过一系列测试后的大根堆:"+myPriorityQueue.toString());

    }


    @Override
    public String toString() {
        String s = "";
        for(int i =0;i<usedSize;i++){
            s+=" "+arr[i].val;
        }
        return s;
    }

根据测试后的结果来看：没有任何问题。

当然如果想建一个小根堆，直接修改一下比较规则即可。