【数据结构】—— 6、优先队列和堆

1、优先队列

优先队列和其实是队列的一种

• 普通队列：先进先出；后进先出
• 优先队列：出队顺序和入队顺序无关；和优先级相关

2、堆

堆本身也是一棵树，其实堆也有很多种，我们在这里主要使用二叉树来表示堆，说白了，
二叉堆就是满足一些特殊性质的二叉树：

• 二叉堆是一棵完全二叉树

• 堆中某个节点的值总是不大于其父节点的值（所以也叫做最大堆），注意：层次大的元素值不一定小于层次小的元素

• 满二叉树：满二叉树就是对于整颗树来说，除了叶子节点，所有的节点左右孩子都不为空如下图
  

• 完全二叉树：不一定是满二叉树，但它不满的那一部分，也就是缺失节点的那一部分一定是在整颗树的右下侧。对于一个满二叉树来讲，一个树有多少层，节点有多少个其实是固定的（如一层有1个，二层有3个，三层6个），但很多时候我们的元素数量不符合满二叉树的元素数量，所以我们当一层满了后再进入下一层，且从左向右排列元素（即元素一层一层的放）
  

• 二叉树可以和二叉树一样使用左右节点的方式来实现，但是我们可以看到我们现在是一层一层按顺序排放的，所以我们可以用更巧妙的方式来实现 （数组）
  

public class MaxHeap<E extends Comparable<E>> {

    private Array<E> data;
    public MaxHeap(int capacity){
        data = new Array<>(capacity);
    }
    public MaxHeap(){
        data = new Array<>();
    }
    // 返回堆中的元素个数
    public int size(){
        return data.getSize();
    }
    // 返回一个布尔值, 表示堆中是否为空
    public boolean isEmpty(){
        return data.isEmpty();
    }
    // 返回完全二叉树的数组表示中，一个索引所表示的元素的父亲节点的索引
    private int parent(int index){
        if(index == 0)
            throw new IllegalArgumentException("index-0 doesn't have parent.");
        return (index - 1) / 2;
    }
    // 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
    private int leftChild(int index){
        return index * 2 + 1;
    }
    // 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
    private int rightChild(int index){
        return index * 2 + 2;
    }
}

向堆中添加元素和Shift Up

现在我们要添加元素52，先添加到索引为10的位置，然而现在不满足二叉堆的性质，所以要调整52的位置，所以让52和自己的父亲节点依次与父亲节点相比较，如52大于父亲节点，就交换52与父亲节点的位置-------Shift up

	// 向堆中添加元素
    public void add(E e){
        data.addLast(e);
        siftUp(data.getSize() - 1); // 传入它的索引
    }

    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);
        }
    }

从堆中取出元素(最大值)和Shift Down

我们先取出最大值62，因为将两个子树融合成一棵树比较复杂，所以我们可以把最小值16换到根节点，然后在采用shift-down操作，

shift-down：把16与左右两个孩子节点相比较，选择两个孩子中最大的那个元素，如果最大的那个元素比16大，则将16与它交换，很显然52与16做交换

然后继续与41做交换

因为16比15大，所以就完成啦

我们来看下代码:

 // 看堆中的最大元素
    public E findMax(){
        if(data.getSize() == 0)
            throw new IllegalArgumentException("Can not findMax when heap is empty.");
        return data.get(0);
    }

    // 取出堆中最大元素
    public E extractMax(){

        E ret = findMax(); // 找到最大的元素(根元素)

        data.swap(0, data.getSize() - 1); // 交换0下标元素和最后一位元素
        data.removeLast(); // 删除原0下标元素
        siftDown(0);

        return ret;
    }

    private void siftDown(int k){

        while(leftChild(k) < data.getSize()) { // 叶子节点
            int j = leftChild(k); // 在此轮循环中,data[k]和data[j]交换位置
            // k左右孩子中较大的一个
            if( j + 1 < data.getSize() &&
                    data.get(j + 1).compareTo(data.get(j)) > 0 ) {
                j++;   // data[j] 是 leftChild 和 rightChild 中的最大值
            }
            
            if(data.get(k).compareTo(data.get(j)) >= 0 )
                break;

            data.swap(k, j);
            k = j;
        }
    }

基于堆的优先队列

public class PriorityQueue<E extends Comparable<E>> implements Queue<E> {

    private MaxHeap<E> maxHeap;
    public PriorityQueue(){
        maxHeap = new MaxHeap<>();
    }

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

    @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();
    }
}