堆的原理與實現

funtrin發表於2021-09-21

堆的原理與實現

概述

堆是一種資料結構，它可以保證，無論以何種順序向堆中新增數，新增多少數，每一次取出來的都是當前堆中最小的數或者最大的數。我們可以把堆想象成一種完全二叉樹結構，最小的數或最大的數在根節點的位置上，並且每一個節點都是其對應子樹中的最小值或最大值。如下圖所示：

image

一棵深度為k的有n個結點的二叉樹，對樹中的結點按從上至下、從左到右的順序進行編號，如果編號為i（1≤i≤n）的結點與滿二叉樹中編號為i的結點在二叉樹中的位置相同，則這棵二叉樹稱為完全二叉樹。

但實際上我們一般使用陣列來實現堆，而不是二叉樹（二叉樹也可以），因為任意節點的索引與它的父子節點的索引之間是有規律的。假設任意節點在陣列中的索引為i，那麼它的父子節點的索引與它的索引有如下關係：

  • 父節點索引：i/2
  • 左子節點索引：2 * i + 1
  • 右子節點索引：2 * i + 2

如下圖所示：

image

如何實現堆？

插入資料

知道了堆的本質是一個陣列，那麼如向堆中插入數字？一般的策略是將要插入的數先放到堆的末尾，然後依次與它的的父節點的值比較，如果小於父節點的值就向上替換，直到數字不小於它的父節點的值或者已經沒有父節點才停止，如下圖所示：

image

程式碼

// 向堆中插入元素
public void heapInsert(int num) {
    // 容量不夠，對陣列進行擴容
    if (size == array.length) {
        array = enlargeArray(array);
    }
    array[size++] = num;
    int index = size - 1;
    while (index > 0) {
        if (array[index] < array[index / 2]) {
            swap(array, index, index / 2);
            index = index / 2;
        } else {
            break;
        }
    }
}

取出最小值

取出最小值很容易實現，直接刪除並返回陣列中的第一個數就可以了，但為了但為了每一次取出的都是最小值，我們還應該將陣列中剩下的數，也調整成一個堆的結構。一般的策略是將堆中最後一個數放到陣列的第一個位置，然後和它的左右子節點中最小的值比較，如果小於子節點中的最小值，那就把它和子節點中最小的值交換，迴圈往復，知道不小於子節點中的值，或是已經到最後一層才停止。如下圖所示：

image

程式碼

// 返回並刪除最小元素
public int pop() {
    int temp = array[0];
    array[0] = array[--size];
    int index = 0;
    int left = 1;
    while (left < size) {
        int min = 0;
        if (left + 1 < size) {
            min = array[left] < array[left + 1] ? left : left + 1;
        } else {
            min = left;
        }
        if (array[index] > array[min]) {
            swap(array, min, index);
            index = min;
            left = index * 2 + 1;
        } else {
            break;
        }
    }
    return temp;
}

完整程式碼

每個人的具體實現不同，程式碼僅供參考。

public class Heap {
    // 初始容量為8
    private int[] array = new int[8];
    private int size = 0;

    public Heap() {
    }

    // 向堆中插入元素
    public void heapInsert(int num) {
        if (size == array.length) {
            array = enlargeArray(array);
        }
        array[size++] = num;
        int index = size - 1;
        while (index > 0) {
            if (array[index] < array[index / 2]) {
                swap(array, index, index / 2);
                index = index / 2;
            } else {
                break;
            }
        }
    }

    // 返回並刪除最小元素
    public int pop() {
        int temp = array[0];
        array[0] = array[--size];
        int index = 0;
        int left = 1;
        while (left < size) {
            int min = 0;
            if (left + 1 < size) {
                min = array[left] < array[left + 1] ? left : left + 1;
            } else {
                min = left;
            }
            if (array[index] > array[min]) {
                swap(array, min, index);
                index = min;
                left = index * 2 + 1;
            } else {
                break;
            }
        }
        return temp;
    }


    // 交換陣列中兩個不同索引上的值
    private void swap(int[] array, int i, int j) {
        array[i] = array[i] ^ array[j];
        array[j] = array[j] ^ array[i];
        array[i] = array[i] ^ array[j];
    }

    // 擴容陣列
    private int[] enlargeArray(int[] array) {
        return Arrays.copyOf(array, array.length * 2);
    }
}

相關文章