堆的原理和實現

一、前言

　　本文將詳細為大家講解關於堆這種數據結構。學了本章以后我們會發現，呃呵，原來...名字聽起來高大上的數據結構也就那么回事。

 

　　后面會持續更新數據結構相關的博文。

　　數據結構專欄：https://www.cnblogs.com/hello-shf/category/1519192.html

　　git傳送門：https://github.com/hello-shf/data-structure.git

二、堆

　　堆這種數據結構，有很多的實現，比如：最大堆，最小堆，斐波那鍥堆，左派堆，斜堆等。從孩子節點的個數上還可以分為二叉堆，N叉堆等。本文我們從最大二叉堆堆入手看看堆究竟是什么高大上的東東。

 

　　2.1、什么是堆

　　我們先看看它的定義

堆是一種完全二叉樹（不是平衡二叉樹，也不是二分搜索樹哦）
堆要求孩子節點要小於等於父親節點（如果是最小堆則大於等於其父親節點）

 

　　滿足以上兩點性質即可成為一棵合格的堆數據結構。我們解讀一下上面的兩點性質

　　1，堆是一種完全二叉樹，關於完全二叉樹，在我另一篇博客《二分搜索樹》中有詳細的介紹，要注意堆是一種建立在二叉樹上的數據結構，不同於AVL或者紅黑樹是建立在二分搜索樹上的數據結構。

　　2，堆要求孩子節點要大於等於父親節點，該定義是針對的最大堆。對於最小堆，孩子節點小於或者等於其父親節點。

　　如上所示，只有圖1是合格的最大堆，圖2不滿足父節點大於或者等於孩子節點的性質。圖3不滿足完全二叉樹的性質。

 

 　　2.2、堆的存儲結構

　　前面我們說堆是一個完全二叉樹，其中一種在合適不過的存儲方式就是數組。首先從下圖看一下用數組表示堆的可行性。

 

　　看了上圖，說明數組確實是可以表示一個二叉堆的。使用數組來存儲堆的節點信息，有一種天然的優勢那就是節省內存空間。因為數組占用的是連續的內存空間，相對來說對於散列存儲的結構來說，數組可以節省連續的內存空間，不會將內存打亂。

　　接下來看看數組到二叉堆的下標表示。將數組的索引設為 i。則：

　　左孩子找父節點：parent（i）= （i - 1）/2。比如2元素的索引為5，其父親節點4的下標parent（2）= （5 - 1）/2 = 2；

　　右孩子找父節點：parent（i）= （i-2）/ 2。比如0元素找父節點 （6-2）/2= 2；

　　其實可以將上面的兩種方法合並成一個，即parent（i）= （i - 1）/2；從java語法出發大家可以發現，整數相除得到的就是省略了小數位的。所以。。。你懂得。

　　同理

　　父節點找左孩子：leftChild(i)= parent(i)* 2 + 1。

　　父節點找右孩子：rightChild(i) = parent(i)*2 + 2。

 

 三、最大二叉堆的實現

 

　　3.1、構建基礎代碼

　　上面分析了數組作為堆存儲結構的可行性分析。接下來我們通過數組構建一下堆的基礎結構

/**
 * 描述：最大堆
 *
 * @Author shf
 * @Date 2019/7/29 10:13
 * @Version V1.0
 **/
public class MaxHeap<E extends Comparable<E>> {
    //使用數組存儲
    private Array<E> data;
    public MaxHeap(){
        data = new Array<>();
    }
    public MaxHeap(int capacity){
        data = new Array<>(capacity);
    }
    public int size(){
        return this.data.getSize();
    }
    public boolean isEmpty(){
        return this.data.isEmpty();
    }

    /**
     * 根據當前節點索引 index 計算其父節點的 索引
     * @param index
     * @return
     */
    private int parent(int index) {
        if(index ==0){
            throw new IllegalArgumentException("該節點為根節點");
        }
        return (index - 1) / 2;//這里為什么不分左右？因為java中 / 運算符只保留整數位。
    }

    /**
     * 返回索引為 index 節點的左孩子節點的索引
     * @param index
     * @return
     */
    private int leftChild(int index){
        return index*2 + 1;
    }

    /**
     * 返回索引為 index 節點的右孩子節點的索引
     * @param index
     * @return
     */
    private int rightChild(int index){
        return index*2 + 2;
    }
}

 

　　3.2、插入和上浮 sift up

　　向堆中插入元素意味着該堆的性質可能遭到破壞，所以這是如同向AVL中插入元素后需要再平衡是一個道理，需要調整堆中元素的位置，使之重新滿足堆的性質。在最大二叉堆中，要堆化一個元素，需要向上查找，找到它的父節點，大於父節點則交換兩個元素，重復該過程直到每個節點都滿足堆的性質為止。這個過程我們稱之為上浮操作。下面我們用圖例描述一下這個過程：

　　如上圖5所示，我們向該堆中插入一個元素15。在數組中位於數組尾部。

　　如圖6所示，向上查找，發現15大於它的父節點，所以進行交換。

　　如圖7所示，繼續向上查找，發現仍大於其父節點14。繼續交換。

　　然后還會繼續向上查找，發現小於其父節點19，停止上浮操作。整個二叉堆通過上浮操作維持了其性質。上浮操作的時間復雜度為O(logn)

　　插入和上浮操作的代碼實現很簡單，如下所示。

    /**
     * 向堆中添加元素
     * @param e
     */
    public void add(E e){
        // 向數組尾部添加元素
        this.data.addLast(e);
        siftUp(data.getSize() - 1);
    }

    /**
     * 上浮操作
     * @param k
     */
    private void siftUp(int k) {
        // 上浮，如果大於父節點，進行交換
        while(k > 0 && get(k).compareTo(get(parent(k))) > 0){
            data.swap(k, parent(k));
            k = parent(k);
        }
    }

 

 　　

 　　3.3、取出堆頂元素和下沉 sift down

　　上面我們介紹了插入和上浮操作，那刪除和下沉操作將不再是什么難題。一般的如果我們取出堆頂元素，我們選擇將該數組中的最后一個元素替換堆頂元素，返回堆頂元素，刪除最后一個元素。然后再對該元素做下沉操作 sift down。接下來我們通過圖示看看一下過程。

　　如上圖8所示，將堆頂元素取出，然后讓最后一個元素移動到堆頂位置。刪除最后一個元素，這時得到圖9的結果。

 

　　如圖10，堆頂的9元素會分別和其左右孩子節點進行比較，選出較大的孩子節點和其進行交換。很明顯右孩子17大於左孩子15。即和右孩子進行交換。

　　如圖11，9節點繼續下沉最終和其左孩子12交換后，再沒有孩子節點。此次過程的下沉操作完成。下沉操作的時間復雜度為O(logn)

　　代碼實現仍然是非常簡單

    /**
     * 取出堆中最大元素
     * 時間復雜度 O（logn）
     * @return
     */
    public E extractMax(){
        E ret = findMax();
        this.data.swap(0, (data.getSize() - 1));
        data.removeLast();
        siftDown(0);
        return ret;
    }

    /**
     * 下沉操作
     * 時間復雜度 O（logn）
     * @param k
     */
    public void siftDown(int k){
        while(leftChild(k) < data.getSize()){// 從左節點開始，如果左節點小於數組長度，就沒有右節點了
            int j = leftChild(k);
            if(j + 1 < data.getSize() && get(j + 1).compareTo(get(j)) > 0){// 選舉出左右節點最大的那個
                j ++;
            }
            if(get(k).compareTo(get(j)) >= 0){// 如果當前節點大於左右子節點，循環結束
                break;
            }
            data.swap(k, j);
            k = j;
        }
    }

 

　　3.4、Replace和Heapify

　　Replace操作呢其實就是取出堆頂元素然后新插入一個元素。根據我們上面的總結，大家很容易想到。返回堆頂元素后，直接將該元素置於堆頂，然后再進行下沉操作即可。

    /**
     * 取出最大的元素，並替換成元素 e
     * 時間復雜度 O（logn）
     * @param e
     * @return
     */
    public E replace(E e){
        E ret = findMax();
        data.set(0, e);
        siftDown(0);
        return ret;
    }

 

 　　Heapify操作就比較有意思了。Heapify本身的意思為“堆化”，那我們將什么進行堆化呢？根據其存儲結構，我們可以將任意一個數組進行堆化。將一個數組堆化？what？一個個向最大二叉堆中插入不就行了？呃，如果這樣的話，需要對每一個元素進行一次上浮時間復雜度為O(nlogn)。顯然這樣做的話，時間復雜度控制的不夠理想。有沒有更好的方法呢。既然這樣說了，肯定是有的。思路就是將一個數組當成一個完全二叉樹，然后從最后一個非葉子節點開始逐個對飛葉子節點進行下沉操作。如何找到最后一個非葉子節點呢？這也是二叉堆常問的一個問題。相信大家還記得前面我們說過parent(i) = (child(i)-1)/2。這個公式是不分左右節點的哦，自己可以用代碼驗證一下，在前面的parent()方法中也有注釋解釋了。那么最后一個非葉子節點其實就是 （(arr.size())/2 - 1）即可。

　　接下來我們通過圖示描述一下這個過程，假如我們將如下數組進行堆化

　　第一步：轉化為一棵完全二叉樹，如圖12所示。

　　

　　第二步：找到最后一個非葉子節點，如圖13所示。這里我們將還未調整的非葉子節點設為黃色，將即將要調整的置為綠色。調整完成的置為綠邊圓。

　　

　　第三步：下沉，非葉子節點和左右孩子進行比較，選出最大的孩子節點進行交換。交換結果如圖14所示

 

　　第四步：找到下一個非葉子節點。

 

　　第五步：下沉。

　　

　　第六步：找到下一個非葉子節點。

 

　　第七步：下沉。

 

 

 

　　第八步：找到下一個非葉子節點。

 

 

　　第九步：下沉。30節點下沉到56元素的位置，然后繼續下沉，但是發現大於23，下沉結束。

 

 

　　第十步：找到下一個非葉子節點。

 

 

　　第十一步：下沉。對17節點進行下沉操作，直到其直到適合自己的位置。

 

 

　　Heapify的整個過程就完成了。時間復雜度控制在了O(n)。

 　　代碼實現非常的簡單。

    /**
     * Heapify
     * @param arr
     */
    public MaxHeap(E[] arr){
        data = new Array<>(arr);
        for(int i = parent(arr.length - 1); i >= 0; i --){
            siftDown(i);
        }
    }

 

 四、完整代碼

　　

/**
 * 描述：最大堆
 *
 * @Author shf
 * @Date 2019/7/29 10:13
 * @Version V1.0
 **/
public class MaxHeap<E extends Comparable<E>> {
    //使用數組存儲
    private Array<E> data;
    public MaxHeap(){
        data = new Array<>();
    }
    public MaxHeap(int capacity){
        data = new Array<>(capacity);
    }

    /**
     * Heapify
     * @param arr
     */
    public MaxHeap(E[] arr){
        data = new Array<>(arr);
        for(int i = parent(arr.length - 1); i >= 0; i --){
            siftDown(i);
        }
    }
    public int size(){
        return this.data.getSize();
    }
    public boolean isEmpty(){
        return this.data.isEmpty();
    }

    /**
     * 根據當前節點索引 index 計算其父節點的 索引
     * @param index
     * @return
     */
    private int parent(int index) {
        if(index ==0){
            throw new IllegalArgumentException("該節點為根節點");
        }
        return (index - 1) / 2;//這里為什么不分左右？因為java中 / 運算符只保留整數位。
    }

    /**
     * 返回索引為 index 節點的左孩子節點的索引
     * @param index
     * @return
     */
    private int leftChild(int index){
        return index*2 + 1;
    }

    /**
     * 返回索引為 index 節點的右孩子節點的索引
     * @param index
     * @return
     */
    private int rightChild(int index){
        return index*2 + 2;
    }

    /**
     * 向堆中添加元素
     * 時間復雜度 O（logn）
     * @param e
     */
    public void add(E e){
        // 向數組尾部添加元素
        this.data.addLast(e);
        siftUp(data.getSize() - 1);
    }

    /**
     * 上浮操作
     * 時間復雜度 O（logn）
     * @param k
     */
    private void siftUp(int k) {
        // 上浮，如果大於父節點，進行交換
        while(k > 0 && get(k).compareTo(get(parent(k))) > 0){
            data.swap(k, parent(k));
            k = parent(k);
        }
    }

    /**
     * 獲取 index 索引位置的元素
     * 時間復雜度 O（1）
     * @param index
     * @return
     */
    private E get(int index){
        return this.data.get(index);
    }

    /**
     * 查找堆中的最大元素
     * 時間復雜度 O（1）
     * @return
     */
    public E findMax(){
        if(this.data.getSize() == 0){
            throw new IllegalArgumentException("當前heap為空");
        }
        return this.data.get(0);
    }

    /**
     * 取出堆中最大元素
     * 時間復雜度 O（logn）
     * @return
     */
    public E extractMax(){
        E ret = findMax();
        this.data.swap(0, (data.getSize() - 1));
        data.removeLast();
        siftDown(0);
        return ret;
    }

    /**
     * 下沉操作
     * 時間復雜度 O（logn）
     * @param k
     */
    public void siftDown(int k){
        while(leftChild(k) < data.getSize()){// 從左節點開始，如果左節點小於數組長度，就沒有右節點了
            int j = leftChild(k);
            if(j + 1 < data.getSize() && get(j + 1).compareTo(get(j)) > 0){// 選舉出左右節點最大的那個
                j ++;
            }
            if(get(k).compareTo(get(j)) >= 0){// 如果當前節點大於左右子節點，循環結束
                break;
            }
            data.swap(k, j);
            k = j;
        }
    }

    /**
     * 取出最大的元素，並替換成元素 e
     * 時間復雜度 O（logn）
     * @param e
     * @return
     */
    public E replace(E e){
        E ret = findMax();
        data.set(0, e);
        siftDown(0);
        return ret;
    }
}

 

 

 

　　

　　如有錯誤的地方還請留言指正。

　　原創不易，轉載請注明原文地址：https://www.cnblogs.com/hello-shf/p/11393655.html