底层实现数据结构：堆 Heap、优先队列

---

• 一、堆
  • 整体结构思维导图
  • 动态数组实现堆
• 二、优先队列
  • 堆实现优先队列

---

一、堆

---

整体结构思维导图

---

-------------------------------------------------------------------------------- 回到目录

堆的相关知识：

• 堆是一棵完全二叉树；
• 堆要满足的性质是每一个结点都大于孩子，或者都小于孩子结点的值；
  最大堆: 所有结点都比自己的孩子结点大；
  最小堆: 所有结点都比自己的孩子结点小；

数组里的索引公式：

我们用数组来表示堆，位置从0开始（也可以从1开始，只是公式有点小变动）。右下角的三个索引公式可以用肉眼验算。

建堆过程：

我们从最后一个非叶子结点（22）开始建堆，然后依次往前一个节点建堆，在建堆过程中，若位置交换完之后还能继续往下交换，就继续交换直至不能交换为止。
该节点的索引为（(arr.length - 1) - 1) / 2

建最大堆的完整图示（顺序从左到右）：

使用动态数组实现堆

---

注意：

• add()是先把元素加入到动态数组的最后，然后向上浮，注意其中的 siftUp 操作就是将一个元素向上浮使其满足最大堆的操作。
• extractMax()就是取出堆顶的元素并且返回，步骤是先交换堆顶和最后一个元素，然后将新的堆顶往下沉。
• 从 (arr.length - 1 - 1) / 2开始建堆。
• 取出操作只能取最大的元素。
• siftDown() 先把最后一个元素顶到第一位，使树结构保持不变，然后再从左右孩子中找最大的反复交换位置让其重新满足最大堆性质。

    //若是使用的自己实现的数组，在Array基础上再加两个函数
    public void swap(int i, int j) {
        if (i < 0 || i >= size || j < 0 || j >= size)
            throw new IllegalArgumentException("illegal");
        E t = data[i];
        data[i] = data[j];
        data[j] = t;
    }

    public Array(E[] arr) {
        data = (E[])new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        size = arr.length;
    }

---

public class MaxHeap<E extends Comparable<E>> {
	private Array<E> data;	//可用自己实现的，也可用java自带的

    //构造函数
    public MaxHeap(int capacity) {
        data = new Array<>(capacity);
    }

    public MaxHeap() {
        data = new Arary<>();
    }

    public MaxHeap(E[] arr) {
        data = new Array<>(arr);
        // Heapify 的过程(将任意数组整理成堆的形状)
        for (int i = parent(arr.length - 1); i >= 0; i--)
            siftDown(i);
    }

    //定位节点的3个辅助函数
    //返回完全二叉树的数组表示中，一个索引所表示的元素的父亲节点的索引
    private int parent(int index) {
        if (index == 0)
            throw new IllegalArgumentException("fail");
        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);
    }

	//改
    //因为这是二叉树，有左边永远比右边小的性质，往上一直找节点交换就行
    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); 
        }
    }

    private void siftDown(int k) {
        //若k的左孩子索引越界了（索引超过数组长度），则代表k已到达叶子节点
        while (leftChild(k) < data.getSize()) {
            int j = leftChild(k);
            //j + 1 为右孩子，
            if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0)
                j = rightChild(k);
                
            //经过上面的操作此时 data[j] 是 leftChild 和 rightChild 中的最大值

			//对比父节点和孩子节点，若父节点大，则没有违反最大堆性质
            if (data.get(k).compareTo(data.get(j)) >= 0)
                break;

            data.swap(k, j);
            k = j;  //赋值后用于进行下一层的比较
        }
    }

    //取出堆中最大元素
    public E extractMax() {
        E ret = findMax();
        data.swap(0, data.getSize() - 1);
        data.removeLast();
        siftDown(0);
        return ret;
    }

    //取出堆中最大元素，替换为元素e
    public E replace(E e) {
        E ret = findMax();

        data.set(0,e);
        siftDown(0);

        return ret;
    }

	//查
    //看堆中最大元素
    public E findMax() {
        if (data.getSize() == 0)
            throw new IllegalArgumentException("fail");
        return data.get(0);
    }

    //长度函数，返回堆中的元素个数
    public int size() {
        return data.getSize();
    }

    //判空函数
    public boolean isEmpty() {
        return data.isEmpty();
    }

}

-------------------------------------------------------------------------------- 回到目录

二、优先队列

---

什么时候用优先队列？

使用堆使用优先队列

---

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 E getFront() {
        return maxHeap.findMax();
    }

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

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

-------------------------------------------------------------------------------- 回到目录