java实现（3）-堆

引言

堆，我们一般作为二叉堆的一种总称，它是建立在二叉树之上的。在本篇博文中，会详细介绍堆的结构和原理，以至于写出堆的实现。在代码实现中我们主要是针对于插入和删除做一些操作，在删除中我们只考虑删除最小的，而不涉及更深一步的操作。笔者目前整理的一些blog针对面试都是超高频出现的。大家可以点击链接：http://blog.csdn.net/u012403290

场景引入

我们在考虑优先队列的时候会有这样的场景：比如说整个公司都用同一台打印机。一般说来会有队列实现，它遵循FIFO的规则，先提交打印任务的先打印，这无可厚非。但是在实际中，我们希望重要的文件先打印，比如说甲有50页不重要的文件和乙有2页重要文件，甲先提交，这种情况下，我们希望乙能够先打印。FIFO的规则显然不合适。
继续讨论这个问题，如果我们用自定义的链表实现呢？这里可以分为两种情况：
①如果链表是有序的，那么删除最小的元素的时间复杂度是O(1)（如果对时间复杂度不明白的可以查阅相关资料，或者查看我前几篇博文，在这里我详细写过计算方法：http://blog.csdn.net/u012403290/article/details/65631285），但是插入的时间复杂度就是O(N)。
②如果链表是无序的，那么插入定义为插入到最尾部，那么时间复杂度是O(1)，但是删除最小的元素时间复杂度就是O(N)。
继续深究一下，如果我用二叉查找树呢？
按照二叉查找树的性质来说，我们插入和删除最小元素的时间复杂度都是O(Log N)，相比于链表来说有一定的优化，但是我们要考虑一个问题，频繁的删除最小节点，会导致二叉查找树的退化，也就是说二叉查找树的右子树会比左子树大的多，也有可能会直接退化成链表。

完全二叉树

通俗来说，在除最后一层外，每一层上的节点数均达到最大值，在最后一层上只缺少右边的若干结点。大家可以看下面这张图理解：

再说明一下，只能缺少右边的若干节点，并不是可以缺少右子节点。

二叉堆

堆是一颗被完全填满的二叉树，如果没有填满，那么只能是在最后一层，而且在这层上，所有的元素从左到右填入，如果有空缺，只能空缺右边的元素。通俗来说它就是一颗完全二叉树。同时它分为两类描述：
①最小堆
意思就是最小的元素在堆顶，且每一个父节点的值都要小于子节点，下图就是一个最小堆：

②最大堆
意思就是最大的在堆顶，且每一个父节点的值都大于子节点，下图就是一个最大堆：

我们在代码实现过程中，已最小堆为例。

代码实现

1、描述方式
我们思考二叉堆，发现他不需要用链表来表述，直接用数组就可以表述了，我们尝试把二叉堆从上至下，一层一层平铺成数组。我们把上面的最小堆用数组表示就是：

我们对于其进行描述，对于一个二叉堆平铺之后的数组，我们可以发现，任意一个下标元素arr[i]，他的左孩子的就是arr[2*i]，他的右孩子就是arr[2*i+1]，他的父节点就是arr[i/2]。

为什么可以用数组来表述二叉堆？
因为完全二叉树的性质，只能在最后一层的右侧允许缺少节点，而这些节点在数组中处于连续的末端，并不影响前面的所有元素。

2、插入
二叉堆的插入还是很有意思的，一般，我们采用上滤的方式来解决二叉堆的插人：①确认一个可以插入的预插入位置，如果最后一层不满的话，那就插入到最后一层最靠左的那个位置，如果最后一层已满的话，那就新开一层，插入到最左边；②判断把当前数据放入到这个位置是否会破坏二叉堆的性质，如果不破坏，那么插入结束；③如果不符合，那么就需要把这个预插入位置和它的父节点进行兑换；重复②③步骤，直至插入结束。
下面这张图描述了这种插入过程：

3、删除
理解了插入的过程，删除其实也不难的。想对应的，我们称这种方法为下滤。在最小堆中，我们知道如果要删除最小的，那么其实就是删除堆顶就可以了。可想而知，那我们删除之后，有必要把整个二叉堆恢复到满足的条件。也就是说：①移除堆顶元素。并指定当前位置为预插入位置，并尝试把最后一个元素（最后一个元素在二叉堆的最后一层的最后一个位置）放到这个②如果不能顺利插入，那么就比较它的孩子，把较小的孩子放入这个预插入位置。③继续处理这个预插入位置，循环②步骤，直至又形成一个完整的二叉堆位置。
下面这张图描述了这种删除最小的过程：

代码实现

以下是用代码实现的二叉堆，包含了初始化，插入和删除：

package com.brickworkers;public class Heap<T extends Comparable<? super T>> {    private static final int DEFAULT_CAPACITY = 10; //默认容量    private T[] table; //用数组存储二叉堆    private int size; //表示当前二叉堆中有多少数据    public Heap(int capactiy){        this.size = 0;//初始化二叉堆数据量        table = (T[]) new Comparable[capactiy + 1];//+1是因为我们要空出下标为0的元素不存储    }    public Heap() {//显得专业些，你就要定义好构造器        this(DEFAULT_CAPACITY);    }    //插入    public void insert(T t){        //先判断是否需要扩容        if(size == table.length - 1){            resize();        }        //开始插入        //定义一个预插入位置下标        int target = ++size;        //循环比较父节点进行位置交换        for(table[ 0 ] = t; t.compareTo(table[target/2]) < 0; target /= 2){            table[target] = table[target/2];//如果满足条件，那么两者交换，知道找到合适位置（上滤）        }        //插入数据        table[target] = t;        print();    }    //删除最小    //删除过程中，需要重新调整二叉堆（下滤）    public void deleteMin(){        if(size == 0){            throw new IllegalAccessError("二叉堆为空");        }        //删除元素        table[1] = table[size--];        int target  = 1;//从顶部开始重新调整二叉堆        int child;//要处理的节点下标        T tmp = table[ target ];        for( ; target * 2 <= size; target = child )        {            child = target * 2;            if( child != size &&table[ child + 1 ].compareTo( table[ child ] ) < 0 ){//如果右孩子比左孩子小                child++;            }            if( table[ child ].compareTo( tmp ) < 0 ){                table[ target ] = table[ child ];                table[child] = null;            }            else{                 break;            }        }        table[ target ] = tmp;        print();    }    //如果插入数据导致达到数组上限，那么就需要扩容    private void resize(){          T [] old = table;          table = (T [])  new Comparable[old.length*2 + 1];//把原来的数组扩大两倍          for( int i = 0; i < old.length; i++ )              table[ i ] = old[ i ];        //数组进行拷贝    }    //打印数组    private void print(){        System.out.println();        for (int i = 1; i <= size; i++) {            System.out.print(table[i] + " ");        }        System.out.println("二叉堆大小:"+size);    }    public static void main(String[] args) {        Heap<Integer> heap = new Heap<>();        //循环插入0~9的数据        for (int i = 0; i < 10; i++) {            heap.insert(i);        }        //循环删除3次，理论上是删除0,1,2         for (int i = 0; i < 3; i++) {            heap.deleteMin();        }    }}//输出结果：////0 二叉堆大小:1////0 1 二叉堆大小:2////0 1 2 二叉堆大小:3////0 1 2 3 二叉堆大小:4////0 1 2 3 4 二叉堆大小:5////0 1 2 3 4 5 二叉堆大小:6////0 1 2 3 4 5 6 二叉堆大小:7////0 1 2 3 4 5 6 7 二叉堆大小:8////0 1 2 3 4 5 6 7 8 二叉堆大小:9////0 1 2 3 4 5 6 7 8 9 二叉堆大小:10////1 3 2 7 4 5 6 9 8 二叉堆大小:9////2 3 5 7 4 8 6 9 二叉堆大小:8////3 4 5 7 9 8 6 二叉堆大小:7

尾记

这里，对于新手来说有一个小小的规则。对于一个类，代码模块存放顺序一般都是：静态成员变量/常量，构造方法，public方法，private方法。我主要说的是要把你封装起来的private方法放到最后面，因为别人查看你的代码的时候，别人希望最先看到的是你暴露出来的public方法，而不是对他来说无关紧要的private方法。

希望对你有所帮助。