Heap 排序法 - 改良的选择排序

[b]說明[/b]
選擇排序法的概念簡單，每次從未排序部份選一最小值，插入已排序部份的後端，其時間主要花費於在整個未排序部份尋找最小值，如果能讓搜尋最小值的方式加快，選擇排序法的速率也就可以加快，Heap排序法讓搜尋的路徑由樹根至最後一個樹葉，而不是整個未排序部份，因而稱之為改良的選擇排序法。
[b]解法[/b]
Heap排序法使用Heap Tree（堆積樹），樹是一種資料結構，而堆積樹是一個二元樹，也就是每一個父節點最多只有兩個子節點（關於樹的詳細定義還請見資料結構書籍），堆積樹的父節點若小於子節點，則稱之為最小堆積（Min Heap），父節點若大於子節點，則稱之為最大堆積（Max Heap），而同一層的子節點則無需理會其大小關係，例如下面就是一個堆積樹：
[img]http://caterpillar.onlyfun.net/Gossip/AlgorithmGossip/images/heapSort-1.jpg[/img]


可以使用一維陣列來儲存堆積樹的所有元素與其順序，為了計算方便，使用的起始索引是1而不是0，索引1是樹根位置，如果左子節點儲存在陣列中的索引為s，則其父節點的索引為s/2，而右子節點為s+1，就如上圖所示，將上圖的堆積樹轉換為一維陣列之後如下所示：
[img]http://caterpillar.onlyfun.net/Gossip/AlgorithmGossip/images/heapSort-2.jpg[/img]

首先必須知道如何建立堆積樹，加至堆積樹的元素會先放置在最後一個樹葉節點位置，然後檢查父節點是否小於子節點（最小堆積），將小的元素不斷與父節點交換，直到滿足堆積樹的條件為止，例如在上圖的堆積加入一個元素12，則堆積樹的調整方式如下所示：
[img]http://caterpillar.onlyfun.net/Gossip/AlgorithmGossip/images/heapSort-3.jpg[/img]

建立好堆積樹之後，樹根一定是所有元素的最小值，您的目的就是：

1. 將最小值取出
2. 然後調整樹為堆積樹


不斷重複以上的步驟，就可以達到排序的效果，最小值的取出方式是將樹根與最後一個樹葉節點交換，然後切下樹葉節點，重新調整樹為堆積樹，如下所示：
[img]http://caterpillar.onlyfun.net/Gossip/AlgorithmGossip/images/heapSort-4.jpg[/img]

調整完畢後，樹根節點又是最小值了，於是我們可以重覆這個步驟，再取出最小值，並調整樹為堆積樹，如下所示：
[img]http://caterpillar.onlyfun.net/Gossip/AlgorithmGossip/images/heapSort-5.jpg[/img]

如此重覆步驟之後，由於使用一維陣列來儲存堆積樹，每一次將樹葉與樹根交換的動作就是將最小值放至後端的陣列，所以最後陣列就是變為已排序的狀態。

其實堆積在調整的過程中，就是一個選擇的行為，每次將最小值選至樹根，而選擇的路徑並不是所有的元素，而是由樹根至樹葉的路徑，因而可以加快選擇的過程，所以Heap排序法才會被稱之為改良的選擇排序法。

public class Sort {
    public static void heap(int[] number) {
        int[] tmp = new int[number.length + 1];

        // 配合說明，使用一個有偏移的暫存陣列
        for(int i = 1; i < tmp.length; i++) {
            tmp[i] = number[i-1];   
        }

        doHeap(tmp);

        int m = number.length; 
        while(m > 1) { 
            swap(tmp, 1, m); 
            m--; 

            int p = 1; 
            int s = 2 * p; 

            while(s <= m) { 
                if(s < m && tmp[s+1] < tmp[s]) 
                    s++; 
                if(tmp[p] <= tmp[s]) 
                    break; 
                swap(tmp, p, s); 
                p = s; 
                s = 2 * p; 
            } 
        } 

        // 這邊將排序好的暫存陣列設定回原陣列
        for(int i = 0; i < number.length; i++) {
            number[i] = tmp[i+1];   
        }
    }

    private static void doHeap(int[] tmp) { 
        int[] heap = new int[tmp.length];

        for(int i = 0; i < heap.length; i++)
            heap[i] = -1;

        for(int i = 1; i < heap.length; i++) { 
            heap[i] = tmp[i]; 
            int s = i; 
            int p = i / 2; 
            while(s >= 2 && heap[p] > heap[s]) { 
                swap(heap, p, s); 
                s = p; 
                p = s / 2; 
            } 
        } 

        for(int i = 1; i < tmp.length; i++) 
            tmp[i] = heap[i]; 

    } 

    private static void swap(int[] number, int i, int j) {
        int t = number[i]; 
        number[i] = number[j]; 
        number[j] = t;
    }
}