关于堆的复习

堆的本质

堆的本质是一种优先队列，从逻辑上观察 可以看成一种完全二叉树的模型

堆的逻辑实现

我们往一个队列的尾部去添加元素，然后与他的上一层元素进行比较，判断要进行上浮 还是下沉

手写堆实现

手写堆 这里贴很久之前我跟着黑马视频写过的代码

/**
 * 堆的实现（由完全二叉树加一个数组实现）
 * 父节点大于两个子结点
 */
public class Heap< T extends Comparable< T > > {
    /**
     * 定义一个数组 存放堆中的数据
     */
    private T[] items;
    private int N;

    public Heap (int capatity) {
        //由于堆中0 号位置 不存放元素 所以这里构造的大小 是 capatity + 1
        items = (T[]) new Comparable[capatity + 1];
        N = 0;
    }

    /**
     * 判断索引i处的元素是否小于索引j处的元素
     */
    private boolean less (int i, int j) {
        return items[i].compareTo(items[j]) < 0;
    }

    /**
     * 交换索引i和索引j处的元素
     */
    private void exch (int i, int j) {
        T temp = items[i];
        items[i] = items[j];
        items[j] = temp;
    }

    /**
     * 往堆中插入一个元素
     */
    public void insert (T t) {
        //先将元素直接插入到数组末尾,使用++N 是默认0号索引不存放元素
        items[++N] = t;
        //插入元素可能会破坏堆的性质, 使用上浮算法,让堆中的元素重新有序
        swim(N);
    }

    /**
     * 上浮算法 对指定k索引处的元素进行上浮
     */
    private void swim (int k) {
        //循环 让结点不断与父节点比较 ，循环比较到二叉树的第一层
        while (k > 1) {
            //比较当前结点和父节点
            if (less(k / 2, k)) {
                exch(k / 2, k);
            }
            k = k / 2;
        }
    }

    /**
     * 删除堆中最大的元素,并返回
     * 交换1索引和最大索引的元素
     */
    public T delMax () {
        //获取最大元素
        T max = items[1];
        //将最大元素(item[1]) 与N索引元素交换
        exch(1, N);
        //最大索引元素删除掉
        items[N] = null;
        //元素个数-1
        N--;
        //对1号索引进行下沉算法,让堆重新有序
        sink(1);
        return max;
    }

    /**
     * 下沉算法
     */
    private void sink (int k) {

        //循环遍历，让每一个父结点与左右子结点中的最大值进行比较，判断是否需要交换
        while (2 * k <= N) {
            //记录左右较大结点所在的位置
            int max;
            //判断是否存在右子结点
            if (2 * k + 1 <= N) {
                //存在右子结点
                if (less(2 * k, 2 * k + 1)) {
                    max = 2 * k + 1;
                } else {
                    max = 2 * k;
                }
            } else {
                max = 2 * k;
            }

            //判断最大子结点 和父节点大小关系，是否需要交换
            if (less(k, max)) {
                exch(k, max);
            }

            //变换k值
            k = 2 * k;
        }
    }

    public static void main (String[] args) {
        Heap< String > heap = new Heap< String >(20);
        heap.insert("A");
        heap.insert("B");
        heap.insert("C");
        heap.insert("D");
        heap.insert("E");
        heap.insert("F");
        heap.insert("G");


        String del;
        while ((del = heap.delMax()) != null) {
            System.out.print(del + ",");
        }

    }
}

大顶堆 和小顶堆

        //小顶堆
        Queue<Integer> queue = new PriorityQueue<>((x, y) -> {
            return x - y;
        });
        //大顶堆
        Queue<Integer> queue = new PriorityQueue<>((x, y) -> {
            return y - x;
        });