数据结构学习之堆与优先队列篇(Java)

在实现优先队列之前，我们先学习一下堆这种数据结构，因为用堆实现的优先队列是一种常见的选择，实现的优先队列的算法的时间复杂度是O(logn)级别的。
堆：堆有很多种，其中最主流的方式就是用二叉树来表示一个堆，通常称之为二叉堆(Binary Heap),二叉堆就是一个满足特殊性质的二叉树。
二叉堆是一颗完全二叉树，（满二叉树：对于整棵树来说，除了叶子节点，所有的节点左右孩子都不为空，满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树）完全二叉树有着严谨的定义，我们可以理解为完全二叉树就是把元素排列成树的形状，二叉树中每一层容纳的元素树有限的，当一层容纳不下时，剩下的元素就从树的左侧依次挂载，对于整棵树来说，最下面一层一定都是叶子节点，其次，在最下层的叶子节点的上面一层可能还有叶子节点，但这些叶子节点一定分布在这个树的右侧。堆中任意节点的值总是不大于其父亲节点的值，也就说，父节点的值大于等于孩子节点的值。这样定义的堆叫做最大堆(相应的可以定义最小堆)，最大堆中最大的值就是根节点的值。

因为完全二叉树是一层一层的形式，我们可以给节点加上索引，有索引的情况下使用数组是较好的方式，父节点与孩子节点存在一种逻辑关系，我们使用索引就可以很好的表示出来。

二叉堆的简单实现（增删替换等功能）：

/**
 * @author ymn
 * @version 1.0
 * @date 2020\5\18 0015 15:20
 */
public class MaxHeap<E extends Comparable<E>> {

    private Array<E> data;

    public MaxHeap(int capacity){
        data = new Array<>(capacity);
    }

    public MaxHeap(){
        data = new Array<>();
    }
    //heapify:将任意数组整理成堆的形状
    //heapify的作用：将n个元素逐个添加到一个空堆中，算法复杂度是O(nlogn)的，heapify的过程，算法复杂度为O(n)。
    public MaxHeap(E[] arr){
        data = new Array<>(arr);
        for (int i = parent(data.getSize()-1);i >= 0;i --){
            siftDown(i);
        }
    }

    //返回堆中元素的个数
    public int getSize(){
        return data.getSize();
    }
    //返回一个布尔值，表示堆中是否为空
    public boolean isEmpty(){
        return data.isEmpty();
    }

    //返回完全二叉树的数组表示中，一个节点表示的元素的父节点的索引
    private int parent(int index){
        if (index == 0){
            throw new IllegalArgumentException("0 index doesn't have parent node.");
        }
        return (index - 1) / 2;
    }

    //返回完全二叉树的数组表示中，一个节点表示的元素的左孩子节点的索引
    private int leftChild(int index){
        return (index * 2) + 1;
    }

    //返回完全二叉树的数组表示中，一个节点表示的元素的右孩子节点的索引
    private int rightChild(int index){
        return (index * 2) + 2;
    }

    //向堆中添加元素
    public void add(E e){
        data.addLast(e);
        //参数为数组的最后一个元素的索引
        siftUp(data.getSize() - 1);
    }

    //sift up(上浮）
    //因为我们不知道新添加的元素是否大于其父节点，所以我们要维护维护最大堆的定义（父节点的值大于等于孩子节点的值）
    private void siftUp(int k){
        //上浮节点的索引不能等于根节点的索引
        while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0){
             data.swap(k,parent(k));
             k = parent(k);
        }
    }
    //返回堆中最大的元素
    public E findMax(){
        if (data.getSize() == 0){
            throw new IllegalArgumentException("Can't findMax when heap is empty");
        }
        return data.get(0);
    }

    //取出堆中最大元素
    public E extractMax(){
        E ret = findMax();
        data.swap(0,data.getSize() - 1);
        data.removeLast();
        siftDown(0);
        return ret;
    }
    //sift down(下沉)，目的同样是要维护维护最大堆的定义（父节点的值大于等于孩子节点的值）
    private void siftDown(int k){
        while (leftChild(k) < data.getSize()){
            //获得当前节点的左孩子的索引
            int j = leftChild(k);
            //判断一下当前节点是否有右孩子
            if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0){
                j = rightChild(k);
            }
            //这样data[j]就是leftChild和rightChild的最大值
            data.swap(k,j);
            k = j;
        }
    }
    //取出堆中最大的元素，并且替换成元素e
    public E replace(E e){
        E ret = findMax();
        data.set(0,e);
        siftDown(0);
        return ret;
    }
}

使用我们自己实现的MaxHeap实现优先队列：

/**
 * @author ymn
 * @version 1.0
 * @date 2020\5\18 0018 16:19
 */
public class PriorityQueue<E extends Comparable<E>> implements Queue<E> {

    private MaxHeap<E> maxHeap;

    @Override
    public int getSize() {
        return maxHeap.getSize();
    }

    @Override
    public boolean isEmpty() {
        return maxHeap.isEmpty();
    }

    //入队
    @Override
    public void enqueue(E e) {
        maxHeap.add(e);
    }

    //出队
    @Override
    public E dequeue() {
        return maxHeap.extractMax();
    }

    //获得队首元素
    @Override
    public E getFront() {
        return maxHeap.findMax();
    }
}