2. 程式人生 > >優先佇列或堆及堆排序介紹

優先佇列或堆及堆排序介紹

阿新 • • 發佈：2018-11-01

1 堆的基本概念

堆也叫優先佇列，堆是一種特殊的完全二叉樹資料結構，堆分為兩種，最大堆，最小堆。
最大堆：根節點大於左右兩個子節點的完全二叉樹
最小堆：根節點小於左右兩個子節點的完全二叉樹
堆可以用陣列來儲存，a[i]處存根節點，a[2*i] a[2*i + 1]分別存左子樹的根節點，右子樹的根節點。i從1開始

所以對於一個堆，結點i,其父結點為a[i/2],左子節點a[2*i]，右子節點a[2*i + 1]

2 最大堆

根節點大於左右兩個子節點的完全二叉樹叫最大堆

1 堆的上浮
對於最大堆來說，如果某個結點比其父結點要大，那麼我們應該調整該結點的位置，從而使其滿足堆的結構。調整的思路很簡單，就是將與其父結點交換。這樣一直迴圈下去，直到所有結點滿足堆的結構。這個過程叫做堆的上浮

    /**
     * 堆的上浮，解決子節點比父結點大的問題
     * @param k 節點k上浮
     */
    private void swim(int k){
        //子節點比父結點大
        while (k > 1 && less(k/2,k)){
            //交換兩個節點
            exch(k/2,k);
            k = k/2;
        }
    }

時間複雜度O(logN)

2 堆的下沉
對於最大堆來說，如果我們發現某個結點小於子節點(同時小於兩個結點，或者小於一個結點)。這個時候我們也需要調整堆結構。調整思路就是將該結點與子節點中較大的結點做交換，遞迴下去。直到滿足堆的結構。

    /**
     * 堆的下沉 父結點小於子節點,將父節點與較大的子節點交換
     * @param k
     */
    private void sink(int k){
        if (k > count){
            return;
        }
        int i = 2 * k;
        if (i > count ){
            return;
        }

        //只有左子節點 i = count;
        if ((i + 1 ) > count){
            if
 
 (less(k,i)){
                exch(k,i);
            }
            return;
        }
        //兩個孩子都大於父節點
        if (less(k,i) || less(k,i + 1)){
            if (less(i,i+1)){
                exch(k,i+1);
                sink(i+1);
            }else {
                exch(k,i);
                sink(i);
            }
        }
    }

時間複雜度O(logN)

3 堆的插入
只要將插入的數放在陣列末尾，然後上浮這個結點即可

    /**
     * 插入一個元素，並上浮
     * @param t
     */
    public void insert(T t){
        pq[++count] = t;
        swimBetter(count);
    }

時間複雜度O(logN)

4 堆的刪除
這裡刪除指的是刪除最大的元素，即刪除頂點元素。刪除思路很簡單:獲取陣列第一個元素，然後將第一個元素與最後一個元素交換，並下沉第一個元素即可。

    /**
     * 刪除最大的元素
     * @return
     */
    public T delMax(){
        T t = (T) pq[1];
        //刪除最大的，然後將末尾元素交換，並下沉
        exch(1,count);
        pq[count] = null;
        count--;
        sinkBetter(1);
        return t;
    }

時間複雜度O(logN)

5最大堆實現
接下來我們看堆的完整程式碼：

**
 * @author Created by qiyei2015 on 2018/3/25.
 * @version: 1.0
 * @email: 1273482124@qq.com
 * @description:
 */
public class BaseHeap<T extends Comparable<T>> {

    /**
     * 長度需N + 1
     */
    protected Comparable[] pq;

    /**
     * 容量 pq[1....N]
     */
    protected int N;
    /**
     * 堆中元素個數
     */
    protected int count;

    /**
     * 構造方法
     */
    public BaseHeap() {
        pq = new Comparable[0];
    }

    /**
     * 建立一個初始容量為max的堆
     * @param max
     */
    public BaseHeap(int max) {
        pq = new Comparable[max + 1];
        count = 0;
        N = max;
    }

    /**
     * 陣列建立
     * @param array
     */
    public BaseHeap(Comparable[] array) {
        this.pq = new Comparable[array.length + 1];
        System.arraycopy(array,0,pq,1,array.length);
        N = array.length;
        count = N;
    }

    /**
     * 時候為null
     * @return
     */
    public boolean isEmpty(){
        return count == 0;
    }

    /**
     * 返回堆中元素個數
     * @return
     */
    public int size(){
        return count;
    }

    /**
     * 比較 i < j
     * @param i
     * @param j
     * @return
     */
    protected boolean less(int i ,int j){
        return pq[i].compareTo(pq[j]) < 0;
    }

    /**
     * 交換兩個數
     * @param i
     * @param j
     */
    protected void exch(int i,int j){
        Comparable temp = pq[i];
        pq[i] = pq[j];
        pq[j] = temp;
    }

}
/**
 * @author Created by qiyei2015 on 2018/3/25.
 * @version: 1.0
 * @email: 1273482124@qq.com
 * @description: 最大堆
 */
public class MaxPQ<T extends Comparable<T>> extends BaseHeap{

    /**
     * 無參構造方法
     */
    public MaxPQ() {
        super();
    }

    /**
     * 建立一個初始容量為max的堆
     * @param max
     */
    public MaxPQ(int max) {
        super(max);
    }

    /**
     * 用陣列建立堆,時間複雜度 O(N)
     * @param a
     */
    public MaxPQ(Comparable[] a){
        super(a);
        //最後一個父結點是 count / 2 [count/2...1]這個結點區間的結點都下沉，就是堆了
        for (int i = count/2; i >= 1 ; i--){
            sinkBetter(i);
        }
    }

    /**
     * 插入一個元素，並上浮
     * @param t
     */
    public void insert(T t){
        pq[++count] = t;
        swimBetter(count);
    }

    /**
     * 刪除最大的元素
     * @return
     */
    public T delMax(){
        T t = (T) pq[1];
        //刪除最大的，然後將末尾元素交換，並下沉
        exch(1,count);
        pq[count] = null;
        count--;
        sinkBetter(1);
        return t;
    }

    /**
     * 堆的上浮，解決子節點比父結點大的問題
     * @param k 節點k上浮
     */
    private void swim(int k){
        //子節點比父結點大
        while (k > 1 && less(k/2,k)){
            //交換兩個節點
            exch(k/2,k);
            k = k/2;
        }
    }

    /**
     * 堆的上浮，解決子節點比父結點大的問題,少交換，優化堆的上浮過程
     * @param k 節點k上浮
     */
    private void swimBetter(int k){
        Comparable temp =  pq[k];
        //子節點比父結點大
        while (k > 1 && less(k/2,k)){
            //父結點移到子節點 子節點暫存 不用每次都去新建一個臨時變數來交換
            pq[k] = pq[k/2];
            pq[k/2] = temp;
            k = k/2;
        }
    }


    /**
     * 堆的下沉 父結點小於子節點,將父節點與較大的子節點交換
     * @param k
     */
    private void sink(int k){
        if (k > count){
            return;
        }
        int i = 2 * k;
        if (i > count ){
            return;
        }

        //只有左子節點 i = count;
        if ((i + 1 ) > count){
            if (less(k,i)){
                exch(k,i);
            }
            return;
        }
        //兩個孩子都大於父節點
        if (less(k,i) || less(k,i + 1)){
            if (less(i,i+1)){
                exch(k,i+1);
                sink(i+1);
            }else {
                exch(k,i);
                sink(i);
            }
        }

//        //判斷有左孩子，有孩子就行
//        while (2 * k <= N){
//            int j = 2 * k; //此輪迴圈中 k 與j交換
//            if ((j +1) <= N && less(j,j+1)){
//                j++; //更新為右孩子
//            }
//            //父結點大於子節點
//            if (!less(k,j)){
//                break;
//            }
//            exch(k,j);
//            k = j; //更新k的位置
//        }

    }


    /**
     * 堆的下沉 父結點小於子節點,將父節點與較大的子節點交換
     * @param k
     */
    private void sinkBetter(int k) {
        Comparable temp = pq[k];
        //判斷有左孩子，有孩子就行
        while (2 * k <= count) {
            int j = 2 * k; //此輪迴圈中 k 與j交換
            if ((j + 1) <= count && less(j, j + 1)) {
                j++; //更新為右孩子
            }
            //父結點大於子節點
            if (!less(k, j)) {
                break;
            }

            //將子節點移到父結點,父結點移到子節點 不用每次都去新建一個臨時變數來交換
            pq[k] = pq[j];
            pq[j] = temp;
            k = j; //更新k的位置
        }
    }
}

3 最小堆

與最大堆類似，我們只需要在堆的上浮和下沉改變一下條件，即可建立最小堆

1 最小堆上浮
結點比父節點小，該結點與父節點交換

    /**
     * 堆的上浮，如果子節點比父節點小，就交換
     * @param k 節點k上浮
     */
    private void swim(int k){
        //子節點比父結點大
        while (k > 1 && less(k,k/2)){
            //交換兩個節點
            exch(k/2,k);
            k = k/2;
        }
    }

時間複雜度O(logN)

2 最小堆下沉
父結點大於子節點，該結點與子結點中較小的節點交換

    /**
     * 堆的下沉 父結點大於子節點,將父節點與較小的子節點交換,並下沉子節點
     * @param k
     */
    private void sink(int k){
        if (k > count){
            return;
        }
        int i = 2 * k;
        if (i > count ){
            return;
        }

        //只有左子節點 i = count;
        if ((i+1) > count){
            if (less(i,k)){
                exch(k,i);
            }
            return;
        }

        //父節點與較小的子節點交換
        if (less(i,k) || less(i+1,k)){
            //將父節點與較小的節點交換
            if (less(i,i+1)){
                exch(k,i);
                sink(i);
            }else {
                exch(k,i+1);
                sink(i+1);
            }
        }
    }

時間複雜度O(logN)

3 最小堆實現
完整最小堆程式碼：

package com.qiyei.heap;

/**
 * @author Created by qiyei2015 on 2018/4/16.
 * @version: 1.0
 * @email: 1273482124@qq.com
 * @description: 最小堆
 */
public class MinPQ<T extends Comparable<T>> extends BaseHeap {
    /**
     * 無參構造方法
     */
    public MinPQ() {
        super();
    }

    /**
     * 建立一個初始容量為max的堆
     * @param n
     */
    public MinPQ(int n) {
        super(n);
    }

    /**
     * 用陣列建立堆,時間複雜度 O(N)
     * @param a
     */
    public MinPQ(Comparable[] a){
        super(a);
        for (int i = count/2; i >= 1 ; i--){
            sinkBetter(i);
        }
    }

    /**
     * 插入一個元素
     * @param t
     */
    public void insert(T t){
        pq[++count] = t;
        swimBetter(count);
    }

    /**
     * 刪除最小的元素
     * @return
     */
    public T delMin(){
        T t = (T) pq[1];
        exch(1,count);
        pq[count] = null;
        count--;
        sinkBetter(1);
        return t;
    }

    /**
     * 堆的上浮，如果子節點比父節點小，就交換
     * @param k 節點k上浮
     */
    private void swim(int k){
        //子節點比父結點大
        while (k > 1 && less(k,k/2)){
            //交換兩個節點
            exch(k/2,k);
            k = k/2;
        }
    }

    /**
     * 堆的上浮，如果子節點比父節點小，就交換。優化堆的上浮過程
     * @param k 節點k上浮
     */
    private void swimBetter(int k){
        Comparable temp =  pq[k];
        //子節點比父結點大
        while (k > 1 && less(k,k/2)){
            //父結點移到子節點 子節點暫存 不用每次都去新建一個臨時變數來交換
            pq[k] = pq[k/2];
            pq[k/2] = temp;
            k = k/2;
        }
    }


    /**
     * 堆的下沉 父結點大於子節點,將父節點與較小的子節點交換,並下沉子節點
     * @param k
     */
    private void sink(int k){
        if (k > count){
            return;
        }
        int i = 2 * k;
        if (i > count ){
            return;
        }

        //只有左子節點 i = count;
        if ((i+1) > count){
            if (less(i,k)){
                exch(k,i);
            }
            return;
        }

        //父節點與較小的子節點交換
        if (less(i,k) || less(i+1,k)){
            //將父節點與較小的節點交換
            if (less(i,i+1)){
                exch(k,i);
                sink(i);
            }else {
                exch(k,i+1);
                sink(i+1);
            }
        }
    }


    /**
     * 堆的下沉 父結點大於子節點,將父節點與較小的子節點交換
     * @param k
     */
    private void sinkBetter(int k) {
        Comparable temp = pq[k];
        //判斷有左孩子，有孩子就行
        while (2 * k <= count) {
            int j = 2 * k; //此輪迴圈中 k 與j交換
            if ((j + 1) <= count && less(j+1, j)) {
                j++; //更新為右孩子
            }
            //父結點大於子節點
            if (!less(j, k)) {
                break;
            }

            //將子節點移到父結點,父結點移到子節點 不用每次都去新建一個臨時變數來交換
            pq[k] = pq[j];
            pq[j] = temp;
            k = j; //更新k的位置
        }
    }
}

4 堆排序

有了最大最小堆,堆排序變得非常簡單。首先根據陣列構造堆，然後依次取堆頂元素即可，對於最大堆，需要把倒序賦值陣列。
堆排序的時間複雜度是O(nlogn)

    /**
     * 堆排序
     * @param array
     */
    @Override
    public void sort(Comparable[] array) {
        //時間複雜度O(n)
        MaxPQ maxPQ = new MaxPQ(array);
        for (int i = array.length - 1 ; i >= 0 ; i--){
            //時間複雜度O(logn)
            array[i] = maxPQ.delMax();
        }
    }

最後：
原始碼github https://github.com/qiyei2015/Algorithms heap部分

相關推薦

優先佇列或堆及堆排序介紹

1 堆的基本概念 堆也叫優先佇列，堆是一種特殊的完全二叉樹資料結構，堆分為兩種，最大堆，最小堆。 最大堆：根節點大於左右兩個子節點的完全二叉樹 最小堆：根節點小於左右兩個子節點的完全二叉樹 堆可以用陣列來儲存，a[i]處存根節點，a[2*i] a[2*i + 1]分別存左子樹的

優先佇列（二叉堆）模板

template<class T,int MAX=100003>class BinaryHeap{    private:    int Size;    T * Tarr;    public:    BinaryHeap();    void insert(T x);    T deleteM

《常見演算法和資料結構》優先佇列(2)——二叉堆

二叉堆 本系列文章主要介紹常用的演算法和資料結構的知識，記錄的是《Algorithms I/II》課程的內容，採用的是“演算法（第4版）”這本紅寶書作為學習教材的，語言是java。這本書的名

圖論——Dijkstra+prim演算法涉及到的優先佇列（二叉堆）

【0】README 0.1）為什麼有這篇文章？因為 Dijkstra演算法的優先佇列實現 涉及到了一種新的資料結構，即優先佇列（二叉堆）的操作需要更改以適應這種新的資料結構，我們暫且吧它定義為Distance， 而不是單純的int型別； 【1】因

優先佇列Priority Queue和堆Heap

對COMP20003中的Priority queue部分進行總結。圖片來自於COMP20003 queue佇列，顧名思義特點先進先出 priority queue優先佇列，出來的順序按照優先順序priority大小，越大（小）的先pop。 普通的方法： 　　Unsorted array: 　　　

資料結構實現之最小優先佇列（最小堆）

package xwq.dt; import java.util.Comparator; import java.util.Iterator; import java.util.NoSuchElementException; import xwq.util.

【51Nod - 1163】最高的獎勵 （貪心+優先佇列 或 妙用並查集）

題幹： 有N個任務，每個任務有一個最晚結束時間以及一個對應的獎勵。在結束時間之前完成該任務，就可以獲得對應的獎勵。完成每一個任務所需的時間都是1個單位時間。有時候完成所有任務是不可能的，因為時間上可能會有衝突，這需要你來取捨。求能夠獲得的最高獎勵。 Input 第1行：一個數N，表示

堆及堆的應用

Heap.h #ifndef __HEAP_H__ #define __HEAP_H__ typedef int HPDataType; typedef struct Heap { HPDataType* _hp; int _capacity;

1163】最高的獎勵 （貪心+優先佇列 或 妙用並查集）

題幹： 有N個任務，每個任務有一個最晚結束時間以及一個對應的獎勵。在結束時間之前完成該任務，就可以獲得對應的獎勵。完成每一個任務所需的時間都是1個單位時間。有時候完成所有任務是不可能的，因為時間上可能

堆---實現最小堆及堆的插入與刪除

堆 堆在優先順序佇列的各種實現中，是最高效的一種資料結構 假定在各個資料記錄（或元素）中存在一個能夠標識資料記錄（或元素）的資料項，並將依據該資料項對資料進行組織，則可資料項成為關鍵碼（key） 如果有一個關鍵碼的集合K = {k0 , k1 , k2

java 實現優先佇列(在插入的時候排序)

package helloclean.chintest; /** * 優先佇列的實現: * 實現插入的時候

堆的應用及優先佇列

標頭檔案： #include<queue> 宣告： priority_queue <int> i; priority_queue <double> d; 預設為大根堆，即從大到小排列。  除非： priority_queue &

演算法-優先佇列與堆排序

優先佇列 許多應用程式都需要處理有序的元素，但不一定要求他們全部有序，或是不一定要一次就將他們排序。很多情況下我們會收集一些元素，處理當前鍵值最大的元素，然後再收集更多元素，再處理當前鍵值最大的元素，如此這般。 在這種情況下，一個合適的資料結構應該支援兩種操作：刪除最大元素和插入元素。

洛谷P1631序列合併(二分答案經典好題，或優先佇列堆)

題目鏈解：https://www.luogu.org/problemnew/show/P1631   這題剛看完有點蒙，兩個for迴圈的話不但爆空間，也爆時間啊！ 看了大佬解釋後，發現有2種做法，二分答案或優先佇列(堆)。個人傾向於二分答案。 想到二分答案並不容易，有3點關鍵： 1.題目給

八大排序演算法（六）——優先佇列、堆和堆排序

6.1 API 優先佇列是一種抽象資料型別，它表示了一組值和對這些值的操作。優先佇列最重要的操作就是刪除最大元素和插入元素。 6.2 初級實現 6.2.1 陣列實現（無序） 或許實現優先佇列最簡單方法就是基於下壓棧的程式碼。insert()方法的程式碼和棧的完全一樣。要實現刪除最大元素，

（Java資料結構和演算法）堆---優先佇列、堆排序

堆主要用於實現優先佇列。 利用有序陣列可以實現優先佇列（從小到大或從大到小的陣列），刪除的時間複雜度是O(1)，但是插入的時間複雜度是O(N)。用堆實現優先佇列，插入和刪除的時間複雜度都是O(logN)。 簡介 堆是一種完全二叉樹，且每個節點的值都大於等於子節點值（大根堆）。

排序演算法之——優先佇列經典實現（基於二叉堆）

許多應用都需要處理有序的元素，但有時，我們不要求所有元素都有序，或是一定要一次就將它們排序，許多情況下，我們會收集這些元素裡的最大值或最小值。 這種情況下一個合適的資料結構應該支援兩種操作：插入元素、刪除最大元素。 優先佇列與棧和佇列類似，但它有自己的奇妙之處。 在本文中，會講解基於二叉堆的一種優先佇列

堆、堆排序和優先佇列的那些事

1. 什麼是堆？ 堆是一種資料結構，它是一顆完全二叉樹。 堆分為最大堆和最小堆： 最大堆：任意節點的值不大於其父親節點的值。 最小堆：任意節點的值不小於其父親節點的值。 如下圖所示，就是個最大堆： 注：本文中的程式碼實現是最大堆，最小堆的實現相似，不再冗贅。 2. 堆有什麼用途？ 堆最常用於優先

什麼是二叉堆？什麼是堆排序？什麼是優先佇列？

一.什麼是二叉堆？ 二叉堆本質上是一種完全二叉樹，它分為兩個型別： 1.最大堆 2.最小堆 什麼是最大堆呢？最大堆任何一個父節點的值，都大於等於它左右孩子節點的值。 什麼是最小堆呢？最小堆任何一個父節點的值，都小於等於它左右孩子節點的值。 二叉堆的

堆的實現（大小堆及 優先佇列)

一、堆的概念    堆資料結構是一種陣列物件，它可以被視為一棵完全二叉樹結構。  堆結構的二叉樹儲存是：  最大堆：每個父節點的都大於孩子節點。  最小堆：每個父節點的都小於孩子節點。堆疊中的物體具有一