dom4j实现为list添加父节点_最大堆的实现与原理

本文主要讲的是实现最大堆，最小堆其实直接可以通过最大堆对比较运算做一定的处理，即可以得到。
同时可以参考 Java PriorityQueue 的实现。

堆可以作为优先队列。时间复杂度 O(logn)

为什么使用堆？堆的 API 定义2.添加元素与 siftUpreplaceheapify为什么 heapify 操作会更快?siftDown 的操作更多问题1.D叉堆2.索引堆完整的堆的代码

为什么使用堆？

不管是普通线性结构还是顺序线性结构。要么入队 O(1) 出队 O(n),要么入队 O(n) 出队 O(1)。

堆的入队和出队的时间复杂度都是 O(logn),性能非常好。

堆的 API 定义

public class MaxHeap<E extends Comparable<E>> {    private Array data;public MaxHeap(int capacity) {    }public MaxHeap(E[] arr) {    }// 返回堆中的元素个数public int size() {    }// 返回一个布尔值, 表示堆中是否为空public boolean isEmpty() {    }// 向堆中添加元素public void add(E e) {    }// 看堆中的最大元素public E findMax() {    }// 取出堆中最大元素public E extractMax() {    }/**     * 取出堆中最大元素,并替换成 e     * O(logn)     */public E replace(E e) {    }public void heapify() {    }}

2.添加元素与 siftUp

将元素添加到 array 的末尾，然后需要判断当前节点与其父节点的大小，如果它大于它的父节点，那么需要交换他们。
交换完成之后，需要继续将其父节点与其父亲的父亲节点继续比较，这就是一个 siftUp 的过程。

// 向堆中添加元素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);   }}//性能更好的siftUpprivate void siftUp2(int k, E x) {  E target = data.get(k);  while (k > 0) {     int parent = parent(k);     E e = data.get(parent);     if (e.compareTo(target) >= 0) break;         data.set(k, e);         k = parent(k);  }  data.set(k, target);}

replace

取出堆中的最大元素之后，再放入一个新的元素。操作方法：
1.将堆顶的元素替换成目标元素,添加完新的元素后可能会违背堆的性质。
2.使用 siftDown() 满足堆的性质。

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("Can not findMax when heap is empty.");

   return data.get(0);}

操作步骤:

1.获取到堆顶元素
2.将堆顶元素设置成目标元素
3.因为可能违背了堆的性质，于是调用 siftDown(0) 进行下沉操作。

heapify

what is heapify ?

将任意的一个数组整理成堆的形状.

首先把一个数组看成是一个完全二叉树,然后找到倒数第一个非叶子点，然后倒着从尾向前一个一个 siftDown 就可以了。

如何获取到数组中的第一个非叶子节点？
找到最后一个节点的索引，然后拿到它的父节点的 index 即可。

22 便是第一个非叶子节点，我们从它开始进行下沉操作。

public MaxHeap(E[] arr) {    data = new Array<>(arr);    //找到倒数第一个非叶子节点, 然后倒着往回 siftDown(i)    for (int i = parent(arr.length - 1); i >= 0; i--) {        siftDown(i);    }}

为什么 heapify 操作会更快?

如果直接一个元素一个元素的添加进堆的，需要添加的元素为n。
如果我们直接抛弃叶子节点，直接从它的上一层开始进行heapify，因为堆是一棵完全二叉树，使用 heapify 直接可以抛掉一半的节点。

复杂度分析：

将n个元素逐个插入到一个空堆中，算法复杂度为 O(nlogn)。
heapify 的算法复杂度是 O(n) 的。

siftDown 的操作

上面我们提到的两个操作，replace 和 heapify 都需要调用 siftDown 来进行下沉操作的。

private void siftDown(int k) {    while (leftChild(k)         int j = leftChild(k);        //目的是找到更大的一个孩子        //这行的逻辑是判断当前父节点是否有右孩子,同时这个右孩子比左孩子更多        if (j + 1 1).compareTo(data.get(j)) > 0) {            j++;        }        //父节点比最大的孩子节点大        if (data.get(k).compareTo(data.get(j)) >= 0) {            break;        }        data.swap(k, j);        //父子交换，继续下沉        k = j;    }}

siftDown 的逻辑其实就是将当前节点进行下沉，步骤如下:

1.首先找到 siftDown 的孩子,先找它的左孩子，如果左孩子存在，再找其有没有右孩子，如果两个孩子都有，那么取其中更大的一个来和目标节点比较。如果 leftChild(k) < data.getSize() 则表示当前节点没有孩子节点了，所以它已经属于最深的一层了，不需要继续下沉了。
2.找到了目标节点更大的一个孩子节点之后，和它进行对比，如果它比孩子节点更大，则直接退出，不需要继续下沉了。如果它比孩子节点小，则需要进行交换。
3.交换完成之后，将 k 指向孩子节点的index j，在下一步继续对 j 进行下沉操作。

效率更高的下沉操作:

private void siftDown2(int k, E x) {    int half = size() >>> 1;

    while (k         int child = leftChild(k);        E c = data.get(child);        int right = child + 1;

        if (right  0) {            c = data.get(child = right);        }

        if (x.compareTo(c) >= 0) {            break;        }        k = child;    }

    data.set(k, x);}

完整的堆的代码

本文实现的最大堆的完整代码:

https://github.com/leihuazhe/zane-sf/blob/master/src/main/java/com/zane/sf/heap/MaxHeap.java