构造大根堆和小根堆--数组

大根堆

/**
 * 构造大根堆
 * @param <T>
 */
public class BigHeapTree<T extends Comparable<T>>{
    //存放的元素
    private T[] items;
    //元素个数
    private int size;

    public BigHeapTree(int capacity){
        items = (T[]) new Comparable[capacity + 1];
        size = 0;
    }

    /**
     * 判断第i个元素是否小于第k个元素
     * @param i 下标
     * @param k 下标
     * @return
     */
    public boolean less(int i, int k){
        return items[i].compareTo(items[k]) < 0;
    }

    /**
     * 交换第i和第k个元素
     * @param i
     * @param k
     */
    public void exchange(int i, int k){
        T tmp = items[i];
        items[i] = items[k];
        items[k] = tmp;
    }


    /**
     * 向堆中插入元素
     * @param value
     */
    public void insert(T value){
        //将新增的元素放置k+1的位置，初始size从下标1开始
        items[++size] = value;
        //调整第k个元素的位置
        swim(size);
    }

    /**
     * 使用上浮算法，将k处的元素上浮到正确的位置
     * 判断 k/2 位置的元素位置是否大于 k 处的元素，如果小于就交换，直到k > 1
     * @param k 下标索引
     */
    private void swim(int k){
        while(k > 1){
            //如果 k/2 的元素 小于 k处的元素，就交换
            if(less(k/2, k)){
                exchange(k/2, k);
            }
            k /= 2;
        }
    }


    /**
     * 删除堆中最大的元素
     */
    public T delMax(){
        //1.保存堆中最大的元素
        T max = items[1];
        //2.将堆中最后一个元素交换到最大堆的位置
        exchange(1, size);
        //3.将size处的元素置为null，并且元素-1
        items[size] = null;
        size--;
        //4.将元素归位
        sink(1);
        //5.返回最大元素
        return max;
    }

    /**
     * 使用下浮算法，将k处的元素下浮到正确的位置
     * @param k 下标索引
     */
    private void sink(int k){
        //左节点的下标为：2*k，右节点的下标为：2*k+1
        //1.至少有一个左节点，才继续交换
        while(2*k <= size){
            //2.子节点中最大元素的下标
            int max = 0;
            //3.存在右节点，即存在两个子节点，则选择两个中最大的
            if(2*k + 1 <= size){
                if(less(2*k, 2*k+1)){
                    max = 2*k+1;    //右节点较大
                }else{
                    max = 2*k;      //左节点较大
                }
            }else{  //4.只有左节点
                max = 2*k;
            }

            //5.比较
            if(less(k, max)){   //k较小，需要交换
                exchange(k, max);
            }

            //6.变化k
            k = max;
        }
    }
    
    //打印
    public void print(){
        System.out.println(Arrays.toString(items));
    }
}

小根堆

public class SmallHeapTree<T extends Comparable<T>> {

    //存放堆的容器
    private T[] items;
    //堆的元素个数
    private int size;

    public SmallHeapTree(int capacity){
        items = (T[])new Comparable[capacity+1];
        size = 0;
    }

    /**
     * 判断items[i] 是否小于 items[k]
     * @param i
     * @param k
     * @return
     */
    private boolean less(int i, int k){
        return items[i].compareTo(items[k]) < 0;
    }

    /**
     * 交换items[i]和items[k]
     * @param i
     * @param k
     */
    private void exchange(int i, int k){
        T tmp = items[i];
        items[i] = items[k];
        items[k] = tmp;
    }

    /**
     * 向堆中插入一个元素value，构成小根堆
     * @param value
     */
    public void insert(T value){
        items[++size] = value;
        //对堆进行上浮调整，使其满足小根堆
        swim(size);
    }

    /**
     * //对堆进行上浮调整，使其满足小根堆，将k处的元素放到合适的位置
     * @param k
     */
    private void swim(int k) {
        while(k > 1){
            //如果根节点大于子节点，则交换
            if(!less(k/2,k)){
                exchange(k/2,k);
            }
            k /= 2;
        }
    }

    /**
     * 删除堆顶元素，即最小的元素
     */
    public T delMin(){
        return delMin(1);
    }

    /**
     * 删除堆中索引k处的元素
     * @param k
     */
    private T delMin(int k){
        //保存最小值
        T min = items[k];
        //将堆顶元素与最后一个元素交换
        exchange(k, size);
        //将最后元素置为null
        items[size] = null;
        //元素个数-1
        size--;
        //对堆顶的元素进行下沉调整
        sink(1);
        //返回删除的最小值
        return min;
    }

    /**
     * 对堆中的k索引处的元素进行下沉处理
     * @param k
     */
    private void sink(int k){
        //当至少存在一个左节点时，才进行下沉调整
        while(2*k <= size){
            //保存子节点最小值的索引
            int min = 0;
            //存在右节点时，求两个子节点的最小值
            if(2*k+1<=size){
                if(less(2*k,2*k+1)){
                    min = 2*k;
                }else{
                    min = 2*k+1;
                }
            }else{
                min = 2*k;
            }

            //判断根节点和子节点的最小值的大小,当items[k] > items[min]时需要交换元素
            if(!less(k,min)){
                exchange(k,min);
            }

            //更新
            k = min;
        }
    }

    public void print(){
        System.out.println(Arrays.toString(items));
    }
}