數據結構學習——堆

1 基本介紹

堆數據結構是一種數組對象，它能夠被視爲一顆徹底二叉樹。堆的訪問能夠經過三個函數來進行即，

parent(i)
    return floor(i/2);
left(i)
    return 2i;
right(i)
    return 2i + 1;

left操做能夠經過一步左移操做完成，right操做能夠經過左移並在地位+1實現，parent操做則能夠經過把i右移一位獲得。在實現中一般會使用宏或者內聯函數來實現這三個操做。

二叉堆有兩種，最大堆和最小堆。對於最大堆有

A[i] >= A[left(i)] && A[i] >= A[right(i)]

最小堆則是

A[i] <= A[left(i)] && A[i]<= A[right(i)]

最堆排序算法中，使用的是最大堆，最小堆一般在構造優先隊列時使用。堆能夠被當作是一棵樹，結點在堆中的高度定義爲從本結點到葉子的最長簡單降低路徑上邊的數目；定義堆的高度爲樹根的高度。

2 原理部分

下面就關於堆的幾個基本函數作一下說明：

maxHeapify()，運行時間爲O（lgn）用於保持堆的性質；

bulidMaxHeap()，以線性時間運行，能夠在無序的輸入數組基礎上構造出最大堆；

heapSort()，運行時間爲O(nlgn)，對一個數組原地進行排序。

2.1 保持堆的性質

其輸入爲一個數組A和下標i，當maxHeapify被調用時，咱們假定以leftIi)和right(i)爲根的兩棵二叉樹都是最大堆，但這時A[i]可能小於其子女，這樣就違反了最大堆的性質。maxHeapify讓A[i]在最大堆中「降低」使以i爲根的子樹成爲最大堆。僞代碼以下所示。

maxHeapify(A,i)
    l <- left(i)
    r <- right(i)
    if l <= heap-size[A] and A[l] > A[i]
        then largest <- l
        else largest <- i
    if r <= heap-size[A] and A[r] > A[largest]
        then largest <- r
    if largest != i
        then exchange A[i] <-> A[largest]  // 交換i和比它大的那個子結點
            maxHeapify(A,largest);         // 遞歸調用

2.2 建堆

咱們能夠自底向上用maxHeapify來將一個數組A[1...n]（此處 n = length[A]）變成一個最大堆。子數組A[floor(n/2) + 1)..n]中的元素都是樹中的葉子節點，所以每一個均可以看做是一個只含一個元素的堆。buildMAXHeap對樹中每個其餘節點都調用一次maxHeapify。僞代碼以下所示。

buildMaxHeap(A)
    heap-size[A] <- length[A]
    for i <- floor(length[A] / 2) downto 1
        do max-heapify(A,i)

2.3 堆排序算法

開始時，堆排序算法先用buildMaxHeap將輸入數組A[1..n]（此處 n = length[A]）構形成一個最大堆，由於數組中的最大元素在根A[1]，則能夠經過把它與A[n]互換來達到最終正確的位置。如今，若是從堆中「去掉」節點n（經過減少heap-size[A]），能夠很容易的將A[1..n-1]建成最大堆，原來根的子女還是最大堆，而新的根元素可能違背了最大堆性質。這是調用maxHeapify(A,1)就能夠保持這一性質，在A[1..(n-1)]構造出最大堆。堆排序算法不斷重複這個過程，堆的大小由n-1一直降到2.

heapSort(A)
    buildMaxHeap(A)
    for i <- length[A] downto 2
        do exchange A[1] <-> A[i]
            heap-size[A] <- heap-size[A] - 1
            maxHeapify(A,1)

雖然堆排序算法是一個很nice的算法，可是在實際應用中，快速排序的一個好的實現每每優於堆排序。

3 java實現

3.1 數據結構

Heap.java

import java.io.Serializable;

/**
 * Date: 2014/8/17
 * Time: 16:02
 */
public class Heap implements Serializable{
    private int heapLength;
    private int [] data;

    public int getHeapLength() {
        return heapLength;
    }

    public void setHeapLength(int heapLength) {
        this.heapLength = heapLength;
    }

    public int[] getData() {
        return data;
    }

    public void setData(int[] data) {
        this.data = data;
    }
}

3.2 操做類

HeapSort.java

/**
 * Created with IntelliJ IDEA.
 * Date: 2014/8/17
 * Time: 15:39
 */
public class HeapSort {
    public final static int getLeft(int i) {
        return i << 1;
    }

    public final static int getRight(int i) {
        return (i << 1) + 1;
    }

    public final static int getParent(int i) {
        return i >> 1;
    }

    /**
     * 保持堆的性質
     *
     * @param heap
     * @param i
     */
    public static void maxHeapify(Heap heap, int i) {
        if (null == heap || null == heap.getData() || heap.getData().length <= 0 || i < 0)
            return;
        int l = getLeft(i);
        int r = getRight(i);
        int largest = 0;
        if (l < heap.getHeapLength() && heap.getData()[l] > heap.getData()[i])
            largest = l;
        else
            largest = i;
        if (r < heap.getHeapLength() && heap.getData()[r] > heap.getData()[largest])
            largest = r;
        if (largest != i) {
            int tmp = heap.getData()[i];
            heap.getData()[i] = heap.getData()[largest];
            heap.getData()[largest] = tmp;
            maxHeapify(heap, largest);
        }
    }

    /**
     * 創建最大堆
     *
     * @param array
     * @return
     */
    public static Heap bulidMaxHeap(int[] array) {
        if (null == array || array.length <= 0)
            return null;
        Heap heap = new Heap();
        heap.setData(array);
        heap.setHeapLength(array.length);
        for (int i = (array.length >> 1); i >= 0; i--)
            maxHeapify(heap, i);
        return heap;
    }

    /**
     * 堆排序
     *
     * @param array
     */
    public static void heapSort(int[] array) {
        if (null == array || array.length <= 0)
            return;
        Heap heap = bulidMaxHeap(array);
        if (null == heap)
            return;
        for (int i = heap.getHeapLength() - 1; i > 0; i--) {
            int tmp = heap.getData()[0];
            heap.getData()[0] = heap.getData()[i];
            heap.getData()[i] = tmp;
            heap.setHeapLength(heap.getHeapLength() - 1);
            maxHeapify(heap, 0);
        }
    }
}

3.3 測試類

Main.java

public class Main {

    public static void main(String[] args) {
        int a[] = {9, 3, 4, 1, 5, 10, 7};
        System.out.println("Hello World!");
        Sort sort = new Sort();
//        sort.bubbleSort(a);
//        sort.selectSort(a);
//        sort.insertionSort(a);
        HeapSort.heapSort(a);
        for (int i = 0; i < a.length; i++)
            System.out.println(a[i]);
    }
}

補充的筆記

Top k問題可使用堆來解決：

例如從一個長度爲N的數組A裏面尋找前k大的k個數（k << N），則能夠維護一個堆的長度爲k的最小堆，首先使用A的前k個元素來初始化這個最小堆，而後繼續遍歷k+1到N，若是某一個元素比最小堆的根大，則讓它入堆，最後遍歷完成後便可找到前k大的k個數據。 這樣下來，總費時O（k*logk+（n-k）*logk）=O（n*logk）