2. 程式人生 > >演算法-優先佇列與堆排序

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

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

優先佇列

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

interface MaxPQ<Key extends Comparable<Key>>{
        void insert(Key k); //向優先佇列中插入一個元素
        Key max();          //返回最大元素
 

        Key delMax();       //刪除並返回最大元素
        boolean isEmpty();  //返回佇列是否為空
        int size();         //返回佇列中的元素個數
}

實現

  • 有序陣列：在insert中進行排序
  • 無序陣列：在delMax時查詢最大元素並刪除。
  • 堆：在insert中構造堆，在delMax時需要恢復堆狀態。

對比

表：2.4.2

表2.4.3

堆

定義：當一顆二叉樹的每個節點都大於等於它的兩個子節點時，它被稱為堆有序
使用陣列儲存堆：在一個堆中，位置k的節點的位置為k/2，而它的兩個子節點的位置則分別為2k和2k+1.這樣在不使用指標的情況下我們也可以通過計算陣列的索引在樹中上下移動：從a[k]向上一層就令k等於k/2，向下一層則令k等於2k或2k+1。如圖
這裡寫圖片描述

堆的上浮和下沉

使堆維持有序狀態的操作叫做堆有序化。

由下至上的堆有序化（上浮）

如果堆的有序狀態因為某個節點變得比它的父節點更大而被打破，那麼我們需要通過交換它和它的父節點來修復堆。將這樣的節點不斷的向上移動直到遇到一個更大的父節點。

private void swim(int k){
 while (k > 1 && less(k/2,k)){
     exch(k/2,k);
     k = k/2;
    }
}

由上至下的堆有序化（下沉）

如果堆的有序狀態因為某個節點變得不它的兩個子結點或是其中之一更小而被打破，那麼我們可以通過將它和它的兩個位元組點中的較大者交換來恢復堆。

private void sink(int k){
    while (2*k <= N){
        int j = 2*k;
        if(j < N && less(j,j+1)) j++;
        if(!less(k,j)) break;
        exch(k,j);
        k = j;
    }
}

基於堆的優先佇列

程式碼：

abstract class MaxPQ<Key extends Comparable<Key>>{
    private Key[] pq;
    private int N = 0;
    public MaxPQ(int maxN){
        pq = (Key[]) new Comparable[maxN+1];
    }
    public boolean isEmpty(){
        return N == 0;
    }
    public int size(){
        return N;
    }
    public void insert(Key k){
        pq[++N] = k;
        swim(N);
    }
    public Key delMax(){
        Key max = pq[1];
        exch(1,N--);
        pq[N+1] = null;
        sink(1);
        return max;
    }
    //實現見前面程式碼
    protected abstract boolean less(int i,int j);
    protected abstract void exch(int i,int j);
    protected abstract void swim(int k);
    protected abstract void sink(int k);
}

複雜度

對於一個含有N個元素的基於堆的優先佇列，插入元素操作只需要不超過(lgN+1)次比較，刪除最大元素的操作需要不超過2lgN次比較。

堆的拓展

/**
 * 使用二叉堆實現的索引最小優先佇列
 * class IndexMinPQ是一個支援泛型的索引優先佇列。
 * IndexMinPQ支援普通的insert、delete-the-minimum、delete以及change-the-key方法。
 * 使用者可以使用佇列中的0到maxN-1號索引執行刪除和修改方法。
 * IndexMinPQ支援獲取佇列最小元素，佇列最小元素索引操作。
 * IndexMinPQ支援迭代器迭代所有插入的索引號。
 * 
 * IndexMinPQ的實現使用二叉堆。
 *  The <em>insert</em>, <em>delete-the-minimum</em>, <em>delete</em>,
 *  <em>change-key</em>, <em>decrease-key</em>, and <em>increase-key</em>
 *  操作時間複雜度為O(lgN).
 *  The <em>is-empty</em>, <em>size</em>, <em>min-index</em>, <em>min-key</em>, and <em>key-of</em>
 *  operations 時間複雜度為O（1）.

 * @author xwq
 *
 * @param <Key>
 */
public class IndexMinPQ <Key extends Comparable<Key>> implements Iterable<Integer> {
    private int maxN; //索引優先佇列中元素的最大個數
    private int N; //當前索引優先佇列中元素的個數
    private int[] pq;//使用一級索引的二叉堆
    private int[] qp;//pq的對稱對映 qp[pq[i]] = pq[qp[i]] = i，用於對映key索引對應pq二叉堆中的位置 
    private Key[] keys; //keys[i] = priority of i

    /**
     * 初始化索引區間為（0到maxN-1）的空索引優先佇列
     * @param capacity 
     */
    public IndexMinPQ(int capacity) {
        if(capacity <= 0)
            throw new IllegalArgumentException();
        maxN = capacity;
        N = 0;
        pq = new int[capacity+1];
        qp = new int[capacity+1];
        keys = (Key[])new Comparable[capacity+1];
        //初始每個索引都沒用過
        for(int i=0;i<=maxN;i++) 
            qp[i] = -1;
    }

    /**
     * 如果佇列為空返回true
     * @return 如果佇列為空返回true,否則返回false
     */
    public boolean isEmpty() {
        return N==0;
    }

    /**
     * 佇列的當前元素個數
     * @return 佇列的當前元素個數
     */
    public int size() {
        return N;
    }

    /**
     * 判斷優先佇列是否已存在索引i
     * @param i 索引i
     * @return 如果索引i之前已插入，返回true,否則false
     */
    public boolean contains(int i) {
        return qp[i] != -1;
    }

    /**
     * 返回最小值的索引號
     * @return 最小值的索引號 
     */
    public int minIndex() {
        if(isEmpty())
            throw new NoSuchElementException("IndexMinPQ underflow.");
        return pq[1];
    }

    /**
     * 返回優先佇列最小值，即二叉堆根節點
     * @return 優先佇列最小值
     */
    public Key minKey() {
        if(isEmpty())
            throw new NoSuchElementException("IndexMinPQ underflow.");
        return keys[pq[1]];
    }

    /**
     * 索引i對應優先佇列中的鍵值
     * @param i 索引i
     * @return 索引i對應的鍵值
     */
    public Key keyOf(int i) {
        if(!contains(i))
            throw new NoSuchElementException("IndexMinPQ has not contains index i");
        return keys[i];
    }

    /**
     * 將索引i與鍵值key關聯
     * @param i 索引i
     * @param key 鍵值key
     */
    public void insert(int i,Key key) {
        if(i<0 || i>=maxN)
            throw new IllegalArgumentException("index i out of boundary.");
        if(contains(i))
            throw new IllegalArgumentException("index i has allocted");
        N++;
        qp[i] = N;
        pq[N] = i;//pq,qp互為對映
        keys[i] = key;
        adjustUp(N);
    }

    /**
     * 刪除最小鍵值並返回其對應的索引
     * @return 最小鍵值對應的索引
     */
    public int delMin() {
        if(isEmpty())
            throw new NoSuchElementException("IndexMinPQ underflow.");
        int min = minIndex();
        delete(min);
        return min;
    }

    /**
     * 刪除索引i以及其對應的鍵值
     * @param i 待刪除的索引i
     */
    public void delete(int i){
        if(!contains(i))
            throw new NoSuchElementException("IndexMinPQ has not contains index i");
        int pqi = qp[i];
        swap(pqi,N--);
        adjustUp(pqi);
        adjustDown(pqi);
        qp[i] = -1;     //刪除
        keys[i] = null; //便於垃圾收集
        pq[N+1] = -1; //不是必須，但是加上便於理解
    }

    /**
     * 改變與索引i關聯的鍵值
     * @param i 待改變鍵值的索引
     * @param key 改變後的鍵值
     */
    public void changeKey(int i,Key key) {
        if(!contains(i))
            throw new NoSuchElementException("IndexMinPQ has not contains index i");
        if(keys[i].compareTo(key) == 0)
            throw new IllegalArgumentException("argument key equpal to the original value.");
        if(key.compareTo(keys[i]) > 0)  
            increaseKey(i,key);//原鍵值增加
        else 
            decreaseKey(i,key);//原鍵值減小
    }

    /**
     * 減小與索引i關聯的鍵值到給定的新鍵值
     * @param i  與待減小的鍵值關聯的索引
     * @param key 新鍵值
     */
    public void decreaseKey(int i,Key key) {
        if(!contains(i))
            throw new NoSuchElementException("IndexMinPQ has not contains index i");
        if(key.compareTo(keys[i]) > 0)
            throw new IllegalArgumentException("argument key more than the original value.");
        keys[i] = key;
        int pqi = qp[i];
        adjustUp(pqi);
        adjustDown(pqi);
    }

    /**
     * 增加與索引i關聯的鍵值到給定的新鍵值
     * @param i 與待增加的鍵值關聯的索引
     * @param key 新鍵值
     */
    public void increaseKey(int i,Key key) {
        if(!contains(i))
            throw new NoSuchElementException("IndexMinPQ has not contains index i");
        if(key.compareTo(keys[i])<0)
            throw new IllegalArgumentException("argument key less than the original value");
        keys[i] = key;
        int pqi = qp[i];
        adjustUp(pqi);
        adjustDown(pqi);
    }

    /***************************************************************************
        * General helper functions.
    ***************************************************************************/
    /**
     * 交換一級索引值，以及其對稱對映中的值
     * @param i 使用一級索引的二叉堆的索引i
     * @param j 使用一級索引的二叉堆的索引j
     */
    private void swap(int i,int j) {
        int t = pq[i]; pq[i] = pq[j]; pq[j] = t;
        int qpi = pq[i]; 
        int qpj = pq[j];
        qp[qpi] = i;
        qp[qpj] = j;
    }

    /**
     * 判斷鍵值的大小關係
     * @param i 使用一級索引的二叉堆的索引i
     * @param j 使用一級索引的二叉堆的索引j
     * @return keys[ki] < keys[kj] 返回true,否則返回false 
     */
    private boolean less(int i,int j) {
        int ki = pq[i];
        int kj = pq[j];
        return keys[ki].compareTo(keys[kj]) < 0;
    }

    /***************************************************************************
        * Heap helper functions.
     ***************************************************************************/
    /**
     * 向下調整最小二叉堆
     * @param i 一級索引的二叉堆的索引i，pq陣列的陣列位置
     */
    private void adjustDown(int i) {
        while(2*i <= N) {
            int l = 2*i;
            while(l<N && less(l+1,l))
                l++;
            swap(l,i);
            i = l;
        }
    }

    /**
     * 向上調整最小二叉堆
     * @param i 一級索引的二叉堆的索引i，pq陣列的陣列位置
     */
    private void adjustUp(int i) {
        while(i>1) {
            int p = i/2;
            if(less(p,i))
                break;
            swap(p,i);
             i = p;
        }
    }


    @Override
    public Iterator<Integer> iterator() {
        return new HeapIterator();
    }

    /***************************************************************************
        * Iterators.
     ***************************************************************************/
    /**
     * Returns an iterator that iterates over the keys on the
     * priority queue in ascending order.
     * The iterator doesn't implement <tt>remove()</tt> since it's optional.
     *
     * @return an iterator that iterates over the keys in ascending order
     */
    private class HeapIterator implements Iterator<Integer> {
        // create a new pq
        IndexMinPQ<Key> copy;

        // add all elements to copy of heap
        // takes linear time since already in heap order so no keys move
        public HeapIterator() {
            copy = new IndexMinPQ<Key>(maxN);
            for(int i=1;i<=N;i++) {
                int ki = pq[i];  
                Key key = keys[ki];
                copy.insert(ki, key);
            }
        }
        @Override
        public boolean hasNext() {
            return !copy.isEmpty();
        }
        @Override
        public Integer next() {
            if(!hasNext()) 
                throw new NoSuchElementException("IndexMinPQ underflow.");
            return copy.delMin();
        }
        @Override
        public void remove() {
            throw new UnsupportedOperationException("unsupported remove operation.");
        }
    }

    /**
     * Unit tests the <tt>IndexMinPQ</tt> data type.
     */
    public static void main(String[] args) {
        // insert a bunch of strings
        String[] strings = { "it", "was", "the", "best", "of", "times", "it", "was", "the", "worst" };

        IndexMinPQ<String> pq = new IndexMinPQ<String>(strings.length);
        for (int i = 0; i < strings.length; i++) {
            pq.insert(i, strings[i]);
        }       
        StdOut.print();
        // print each key using the iterator
        for (Integer i : pq) {
            StdOut.println(i + " " + pq.keyOf(i));
        }
        StdOut.println();

     // increase or decrease the key
        for (int i = 0; i < strings.length; i++) {
            if (StdRandom.uniform() < 0.5)
                pq.increaseKey(i, strings[i] + strings[i]);
            else
                pq.decreaseKey(i, strings[i].substring(0, 1));
        }

        // delete and print each key
        while (!pq.isEmpty()) {
            String key = pq.minKey();
            int i = pq.delMin();
            StdOut.println(i + " " + key);
        }
        StdOut.println();

     // reinsert the same strings
        for (int i = 0; i < strings.length; i++) {
            pq.insert(i, strings[i]);
        }

        // delete them in random order
        int[] perm = new int[strings.length];
        for (int i = 0; i < strings.length; i++)
            perm[i] = i;
        StdRandom.shuffle(perm);
        for (int i = 0; i < perm.length; i++) {
            String key = pq.keyOf(perm[i]);
            pq.delete(perm[i]);
            StdOut.println(perm[i] + " " + key);
        }

    }


}

堆排序

有兩種方式：

  • 可以從左到右遍歷陣列，用swim()保證指標左側的所有元素已經是一顆對有序的完全樹
  • 可以從右到左使用sink()函式構造最小子堆，然後找到每個已經有序的子堆的父節點構造下一層堆，這樣遞迴的構造直到到達最終的根結點。

sink()的方法效率很高，因為我們事實上只需要遍歷整個陣列的一半即可使整個堆有序。舉個例子假設我們現在要排序16個元素，先將他們填裝到長度為17的數組裡（0位為空）第一次構造的根結點為5-8，第二次的根結點為3-4，第三次的根結點為2，第四次的根結點為1，堆構造完成（這裡的每次指的是構造同一高度的堆）。這時我們呼叫sink()的次數正好是元素個數的一半。然後交換根結點和陣列最右邊未排好序的節點，sink堆，如此直到堆的長度減小為1，整個陣列即有序。

public static void sort(Comparable[] a){
    int N = a.length;
    for(int k = N/2 ; k >= 1 ; k--)
           sink(a,k,N);
    while (N > 1){
        exch(a,1,N--);
        sink(a,1,N);
       }
}

如圖為堆排序軌跡：
這裡寫圖片描述

複雜度

用下沉操作由N個元素構造堆只需要少於2N次比較以及少於N次交換。將N個元素排序，堆排序只需少於（2NlgN+2N)次比較（以及一半次樹的交換）。

缺點

在現代系統的許多應用中很少用，因為無法利用快取。陣列元素很少和相鄰的其他元素進行比較，因此快取未命中的次數遠遠高於大多數比較都在相鄰元素間進行的演算法，如快速排序，歸併排序，甚至希爾排序。

優先佇列在java中的實現

見java.util.PriorityQueue

相關推薦

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

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

淺談演算法和資料結構: 五 優先順序佇列與堆排序

在很多應用中，我們通常需要按照優先順序情況對待處理物件進行處理，比如首先處理優先順序最高的物件，然後處理次高的物件。最簡單的一個例子就是，在手機上玩遊戲的時候，如果有來電，那麼系統應該優先處理打進來的電話。 在這種情況下，我們的資料結構應該提供兩個最基本的操作，一個是返回最高優先

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

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

《常見演算法和資料結構》優先佇列(3)——堆排序

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

排序演算法（3）—優先佇列，堆排序

本文主要討論基於二叉堆資料結構的優先佇列的實現以及衍生的堆排序 實現優先佇列還可以使用棧，佇列等資料結構，在此略 文章最後附有堆排序完整程式碼 優先佇列 1. 主要解決問題 有時候比不

資料結構——優先佇列與堆

什麼是優先佇列？ 普通佇列:先進先出，後進後出 優先佇列:出隊順序和入隊順序無關；和優先順序相關，如醫院中，病重先安排病床 優先佇列的現例項子： ①cpu任務排程，動態選擇優先順序最高的任務執行 ②王者榮耀中，攻擊鍵優先打敵人，無敵人時候優先打最近的小兵 關於

基於堆的優先佇列和堆排序

          public class MaxPQ<Key extends Comparable<key>>{               private Key[] pq;               private int N = 0;               pulbi

八、優先佇列、堆排序

優先佇列 一種常見的資料結構，需要支援兩種操作：刪除最大(最小)元素和插入元素。這種資料型別叫做優先佇列。 API MaxPQ()//建立一個優先佇列 MaxPQ(int max)//建立一個最大容量為max的優先佇列 MaxPQ(key

優先佇列和堆排序

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

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

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

PAT 備考——優先佇列（堆）與堆排序

一、堆 堆是完全二叉樹型中的一種的資料結構，按照排列順序分為大頂堆和小頂堆。其中大頂堆表示二叉樹中所有根節點比子節點大，小頂堆反之。 因此，以大頂堆為例，堆具有如下兩個性質： 有序性：從根節點到任意子節點的路徑，所經過的節點是有序排列的； 完全性：與完全二叉樹相同，當用陣

優先級隊列與堆排序

缺點 public 概念 對數 col src array 節點 退出 轉自：http://www.cnblogs.com/yangecnu/p/Introduce-Priority-Queue-And-Heap-Sort.html 在很多應用中，我們通常需要按照優先級

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

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

演算法導論 第六章：堆排序 筆記（堆、維護堆的性質、建堆、堆排序演算法、優先順序佇列、堆排序的程式碼實現）

堆排序(heapsort) 像合併排序而不像插入順序，堆排序的執行時間為O(nlgn) 。像插入排序而不像合併排序，它是一種原地( in place) 排序演算法：在任何時候，陣列中只有常數個元素儲存在輸入陣列以外。 堆： （二叉）堆資料結構是一種陣列物件，它可以被視為一棵完全二叉樹。樹

.Kruskal演算法 優先佇列+並查集，用優先佇列代替排序。

程式碼 /* 思路，將邊集加入到最小優先佇列，每次取出一個最小邊，如果邊的兩個端點有一個沒有訪問過，說明加入這條邊，就沒有構成環。可以加入。 突然發現這個思路是錯的。判斷是不是環，我的說法是錯誤的。還沒有想到解決辦法。 如果解決了：加入一條邊

經典排序演算法----堆與堆排序（不穩定）

堆與堆排序（不穩定）穩定性分析我們知道堆的結構是節點i的孩子為2 * i和2 * i + 1節點，大頂堆要求父節點大於等於其2個子節點，小頂堆要求父節點小於等於其2個子節點。在一個長為n 的序列，堆排序的過程是從第n / 2開始和其子節點共3個值選擇最大（大頂堆）或者最小（小

排序演算法（一）：插入排序與堆排序

排序演算法是演算法研究中最基礎的問題，本文針對排序演算法，介紹幾種排序演算法的基本方法、時間複雜度及Java實現等內容。 原址性 ：如果輸入陣列中僅有常數個元素需要在排序的過程中儲存在陣列之外，那麼排序演算法就是原址的。 　　　　　　　　常用排序演算法的執行

POJ 3159 Candies（Dijkstra演算法+優先佇列+堆）

Candies Time Limit: 1500MS Memory Limit: 131072K Total Submissions: 37796 Accepted: 10637 Description During the kinde

優先佇列和堆，與priority_queue的學習筆記

今天花了一天的時間把優先佇列和堆，還有priority_queue給學習了學習，現在做下筆記。學完認識到優先佇列就是堆的一種，而priority_queue是為優先佇列準備的STL，定義與使用起來十分方便。堆先說堆，堆是一個二叉樹，以小根堆為例（大根堆就相反了）兒子的值一定不

《演算法筆記》4. 堆與堆排序、比較器詳解

[TOC] # 比較器與堆 ## 堆結構 ### 完全二叉樹結構 > 完全二叉樹結構：要麼本層是滿的，要麼先滿左邊的，以下都是完全二叉樹 1. ``` graph TD A-->B A-->C ``` 2. ``` graph TD A-->B A-->C B--&