2. 程式人生 > >Java資料結構與演算法：堆

Java資料結構與演算法：堆

阿新 • • 發佈：2019-02-06

1. 堆的定義

設有n個數據元素的關鍵字為（k0、k1、…、kn-1），如果它們滿足以下的關係：ki<= k2i+1且ki<= k2i+2（或ki>= k2i+1且ki>= k2i+2）（i=0、1、…、(n-2)/2）則稱之為堆(Heap)。

如果將此資料元素序列用一維陣列儲存，並將此陣列對應一棵完全二叉樹，則堆的含義可以理解為：在完全二叉樹中任何非終端結點的關鍵字均不大於（或不小於）其左、右孩子結點的關鍵字。

下圖(b)、(c)分別給出了最小堆和最大堆的例子，前者任一非終端結點的關鍵字均小於或等於它的左、右孩子的關鍵字，此時位於堆頂(即完全二叉樹的根結點位置)的結點的關鍵字是整個序列中最小的，所以稱它為最小堆；後者任一非終端結點的關鍵字均大於或等於它的左、右孩子的關鍵字，此時位於堆頂的結點的關鍵字是整個序列中最大的，所以稱它為最大堆。

堆

調整演算法FilterDown要求將以分支結點i為根的子樹調整為最小堆，其基本思想是：從結點i開始向下調整，先比較結點i左孩子結點和右孩子結點的關鍵字大小，如果結點i左孩子結點的關鍵字小於右孩子結點的關鍵字，則沿結點i的左分支進行調整；否則沿結點i的右分支進行調整，在演算法中用j指示關鍵字值較小的孩子結點。然後結點i和結點j進行關鍵字比較，若結點i的關鍵字大於結點j的關鍵字，則兩結點對調位置，相當於把關鍵字小的結點上浮。再令i＝j，j＝2*j十l，繼續向下一層進行比較；若結點i的關鍵字不大於結點j的關鍵字或結點i沒有孩子時調整結束。

堆

注意：這裡的“堆”是指一種的特殊的二叉樹，不要和java和C++等程式語言裡的
“堆”混淆，後者指的是程式設計師用new能得到的計算機記憶體的可用部分。

堆的介紹

  • 堆是完全二叉樹
  • 常常用陣列實現
  • 每一個節點的關鍵字都大於（等於）這個節點的子節點的關鍵字

弱序，優先順序佇列

2. 在堆中插入元素

在堆的類定義中成員函式Insert( )用於在堆中插入一個數據元素，在此規定資料元素總是插在已經建成的最小堆後面，如下圖所示在堆中插入關鍵字為14的資料元素。顯然在堆中插入元素後可能破壞堆的性質，所以還需要呼叫FilterUp( )函式，進行自下而上調整使之所在的子樹成為堆。

堆

在堆的類定義中成員函式DeleteTop( )用於刪除堆頂資料元素。在從堆中刪除堆頂元素後，一般把堆的最後一個元素移到堆頂，並將堆的當前元素個數heapCurrentSize減1，最後需要呼叫FilterDown()函式從堆頂向下進行調整。如圖6-20所示給出了在堆中刪除堆頂元素的過程。

堆

3. 二叉堆

二叉堆就是通常我們所說的資料結構中”堆”中的一種。和以往一樣，本文會先對二叉堆的理論知識進行簡單介紹，然後給出C語言的實現。後續再分別給出C++和Java版本的實現；實現的語言雖不同，但是原理如出一轍，選擇其中之一進行了解即可

4. 堆和二叉堆的介紹

4.1 堆的定義

堆(heap)，這裡所說的堆是資料結構中的堆，而不是記憶體模型中的堆。堆通常是一個可以被看做一棵樹，它滿足下列性質：

  • [性質一] 堆中任意節點的值總是不大於(不小於)其子節點的值；
  • [性質二] 堆總是一棵完全樹。

將任意節點不大於其子節點的堆叫做最小堆或小根堆，而將任意節點不小於其子節點的堆叫做最大堆或大根堆。常見的堆有二叉堆、左傾堆、斜堆、二項堆、斐波那契堆等等。

4.2 二叉堆的定義

二叉堆是完全二元樹或者是近似完全二元樹，它分為兩種：最大堆和最小堆。
最大堆：父結點的鍵值總是大於或等於任何一個子節點的鍵值；最小堆：父結點的鍵值總是小於或等於任何一個子節點的鍵值。示意圖如下：

二叉堆一般都通過”陣列”來實現。陣列實現的二叉堆，父節點和子節點的位置存在一定的關係。有時候，我們將”二叉堆的第一個元素”放在陣列索引0的位置，有時候放在1的位置。當然，它們的本質一樣(都是二叉堆)，只是實現上稍微有一丁點區別。
假設”第一個元素”在陣列中的索引為 0 的話，則父節點和子節點的位置關係如下：

  • 索引為i的左孩子的索引是 (2*i+1);
  • 索引為i的左孩子的索引是 (2*i+2);
  • 索引為i的父結點的索引是 floor((i-1)/2);

假設”第一個元素”在陣列中的索引為 1 的話，則父節點和子節點的位置關係如下：

  • 索引為i的左孩子的索引是 (2*i)
  • 索引為i的左孩子的索引是 (2*i+1)
  • 索引為i的父結點的索引是 floor(i/2)

注意：本文二叉堆的實現統統都是採用”二叉堆第一個元素在陣列索引為0”的方式！

5. 二叉堆的圖文解析

在前面，我們已經瞭解到：”最大堆”和”最小堆”是對稱關係。這也意味著，瞭解其中之一即可。本節的圖文解析是以”最大堆”來進行介紹的。

二叉堆的核心是”新增節點”和”刪除節點”，理解這兩個演算法，二叉堆也就基本掌握了。下面對它們進行介紹。

5.1 新增

假設在最大堆[90,80,70,60,40,30,20,10,50]種新增85，需要執行的步驟如下：

如上圖所示，當向最大堆中新增資料時：先將資料加入到最大堆的最後，然後儘可能把這個元素往上挪，直到挪不動為止！

將85新增到[90,80,70,60,40,30,20,10,50]中後，最大堆變成了[90,85,70,60,80,30,20,10,50,40]。

/*
 * 最大堆的向上調整演算法(從start開始向上直到0，調整堆)
 *
 * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 引數說明：
 *     start -- 被上調節點的起始位置(一般為陣列中最後一個元素的索引)
 */
protected void filterup(int start) {
    int c = start;            // 當前節點(current)的位置
    int p = (c-1)/2;        // 父(parent)結點的位置 
    T tmp = mHeap.get(c);        // 當前節點(current)的大小

    while(c > 0) {
        int cmp = mHeap.get(p).compareTo(tmp);
        if(cmp >= 0)
            break;
        else {
            mHeap.set(c, mHeap.get(p));
            c = p;
            p = (p-1)/2;   
        }       
    }
    mHeap.set(c, tmp);
}

/* 
 * 將data插入到二叉堆中
 */
public void insert(T data) {
    int size = mHeap.size();

    mHeap.add(data);    // 將"陣列"插在表尾
    filterup(size);        // 向上調整堆
}

insert(data)的作用：將資料data新增到最大堆中。mHeap是動態陣列ArrayList物件。

當堆已滿的時候，新增失敗；否則data新增到最大堆的末尾。然後通過上調演算法重新調整陣列，使之重新成為最大堆。

5.2 刪除

假設從最大堆[90,85,70,60,80,30,20,10,50,40]中刪除90，需要執行的步驟如下：

如上圖所示，當從最大堆中刪除資料時：先刪除該資料，然後用最大堆中最後一個的元素插入這個空位；接著，把這個“空位”儘量往上挪，直到剩餘的資料變成一個最大堆。
從[90,85,70,60,80,30,20,10,50,40]刪除90之後，最大堆變成了[85,80,70,60,40,30,20,10,50]。

注意：考慮從最大堆[90,85,70,60,80,30,20,10,50,40]中刪除60，執行的步驟不能單純的用它的位元組點來替換；而必須考慮到”替換後的樹仍然要是最大堆”！

/* 
 * 最大堆的向下調整演算法
 *
 * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 *
 * 引數說明：
 *     start -- 被下調節點的起始位置(一般為0，表示從第1個開始)
 *     end   -- 截至範圍(一般為陣列中最後一個元素的索引)
 */
protected void filterdown(int start, int end) {
    int c = start;          // 當前(current)節點的位置
    int l = 2*c + 1;     // 左(left)孩子的位置
    T tmp = mHeap.get(c);    // 當前(current)節點的大小

    while(l <= end) {
        int cmp = mHeap.get(l).compareTo(mHeap.get(l+1));
        // "l"是左孩子，"l+1"是右孩子
        if(l < end && cmp<0)
            l++;        // 左右兩孩子中選擇較大者，即mHeap[l+1]
        cmp = tmp.compareTo(mHeap.get(l));
        if(cmp >= 0)
            break;        //調整結束
        else {
            mHeap.set(c, mHeap.get(l));
            c = l;
            l = 2*l + 1;   
        }       
    }   
    mHeap.set(c, tmp);
}

/*
 * 刪除最大堆中的data
 *
 * 返回值：
 *      0，成功
 *     -1，失敗
 */
public int remove(T data) {
    // 如果"堆"已空，則返回-1
    if(mHeap.isEmpty() == true)
        return -1;

    // 獲取data在陣列中的索引
    int index = mHeap.indexOf(data);
    if (index==-1)
        return -1;

    int size = mHeap.size();
    mHeap.set(index, mHeap.get(size-1));// 用最後元素填補
    mHeap.remove(size - 1);                // 刪除最後的元素

    if (mHeap.size() > 1)
        filterdown(index, mHeap.size()-1);    // 從index號位置開始自上向下調整為最小堆

    return 0;
}

6. 二叉堆的Java實現

6.1 二叉堆(最大堆)

/**
 * 二叉堆(最大堆)
 *
 * @author skywang
 * @date 2014/03/07
 */

import java.util.ArrayList;
import java.util.List;

public class MaxHeap<T extends Comparable<T>> {

    private List<T> mHeap;    // 佇列(實際上是動態陣列ArrayList的例項)

    public MaxHeap() {
        this.mHeap = new ArrayList<T>();
    }

    /* 
     * 最大堆的向下調整演算法
     *
     * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
     *
     * 引數說明：
     *     start -- 被下調節點的起始位置(一般為0，表示從第1個開始)
     *     end   -- 截至範圍(一般為陣列中最後一個元素的索引)
     */
    protected void filterdown(int start, int end) {
        int c = start;          // 當前(current)節點的位置
        int l = 2*c + 1;     // 左(left)孩子的位置
        T tmp = mHeap.get(c);    // 當前(current)節點的大小

        while(l <= end) {
            int cmp = mHeap.get(l).compareTo(mHeap.get(l+1));
            // "l"是左孩子，"l+1"是右孩子
            if(l < end && cmp<0)
                l++;        // 左右兩孩子中選擇較大者，即mHeap[l+1]
            cmp = tmp.compareTo(mHeap.get(l));
            if(cmp >= 0)
                break;        //調整結束
            else {
                mHeap.set(c, mHeap.get(l));
                c = l;
                l = 2*l + 1;   
            }       
        }   
        mHeap.set(c, tmp);
    }

    /*
     * 刪除最大堆中的data
     *
     * 返回值：
     *      0，成功
     *     -1，失敗
     */
    public int remove(T data) {
        // 如果"堆"已空，則返回-1
        if(mHeap.isEmpty() == true)
            return -1;

        // 獲取data在陣列中的索引
        int index = mHeap.indexOf(data);
        if (index==-1)
            return -1;

        int size = mHeap.size();
        mHeap.set(index, mHeap.get(size-1));// 用最後元素填補
        mHeap.remove(size - 1);                // 刪除最後的元素

        if (mHeap.size() > 1)
            filterdown(index, mHeap.size()-1);    // 從index號位置開始自上向下調整為最小堆

        return 0;
    }

    /*
     * 最大堆的向上調整演算法(從start開始向上直到0，調整堆)
     *
     * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
     *
     * 引數說明：
     *     start -- 被上調節點的起始位置(一般為陣列中最後一個元素的索引)
     */
    protected void filterup(int start) {
        int c = start;            // 當前節點(current)的位置
        int p = (c-1)/2;        // 父(parent)結點的位置 
        T tmp = mHeap.get(c);        // 當前節點(current)的大小

        while(c > 0) {
            int cmp = mHeap.get(p).compareTo(tmp);
            if(cmp >= 0)
                break;
            else {
                mHeap.set(c, mHeap.get(p));
                c = p;
                p = (p-1)/2;   
            }       
        }
        mHeap.set(c, tmp);
    }

    /* 
     * 將data插入到二叉堆中
     */
    public void insert(T data) {
        int size = mHeap.size();

        mHeap.add(data);    // 將"陣列"插在表尾
        filterup(size);        // 向上調整堆
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<mHeap.size(); i++)
            sb.append(mHeap.get(i) +" ");

        return sb.toString();
    }

    public static void main(String[] args) {
        int i;
        int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
        MaxHeap<Integer> tree=new MaxHeap<Integer>();

        System.out.printf("== 依次新增: ");
        for(i=0; i<a.length; i++) {
            System.out.printf("%d ", a[i]);
            tree.insert(a[i]);
        }

        System.out.printf("\n== 最 大 堆: %s", tree);

        i=85;
        tree.insert(i);
        System.out.printf("\n== 新增元素: %d", i);
        System.out.printf("\n== 最 大 堆: %s", tree);

        i=90;
        tree.remove(i);
        System.out.printf("\n== 刪除元素: %d", i);
        System.out.printf("\n== 最 大 堆: %s", tree);
        System.out.printf("\n");
    }
}

6.2 二叉堆(最小堆)

/**
 * 二叉堆(最小堆)
 *
 * @author skywang
 * @date 2014/03/07
 */

import java.util.ArrayList;
import java.util.List;

public class MinHeap<T extends Comparable<T>> {

    private List<T> mHeap;        // 存放堆的陣列

    public MinHeap() {
        this.mHeap = new ArrayList<T>();
    }

    /* 
     * 最小堆的向下調整演算法
     *
     * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
     *
     * 引數說明：
     *     start -- 被下調節點的起始位置(一般為0，表示從第1個開始)
     *     end   -- 截至範圍(一般為陣列中最後一個元素的索引)
     */
    protected void filterdown(int start, int end) {
        int c = start;          // 當前(current)節點的位置
        int l = 2*c + 1;     // 左(left)孩子的位置
        T tmp = mHeap.get(c);    // 當前(current)節點的大小

        while(l <= end) {
            int cmp = mHeap.get(l).compareTo(mHeap.get(l+1));
            // "l"是左孩子，"l+1"是右孩子
            if(l < end && cmp>0)
                l++;        // 左右兩孩子中選擇較小者，即mHeap[l+1]

            cmp = tmp.compareTo(mHeap.get(l));
            if(cmp <= 0)
                break;        //調整結束
            else {
                mHeap.set(c, mHeap.get(l));
                c = l;
                l = 2*l + 1;   
            }       
        }   
        mHeap.set(c, tmp);
    }

    /*
     * 最小堆的刪除
     *
     * 返回值：
     *     成功，返回被刪除的值
     *     失敗，返回null
     */
    public int remove(T data) {
        // 如果"堆"已空，則返回-1
        if(mHeap.isEmpty() == true)
            return -1;

        // 獲取data在陣列中的索引
        int index = mHeap.indexOf(data);
        if (index==-1)
            return -1;

        int size = mHeap.size();
        mHeap.set(index, mHeap.get(size-1));// 用最後元素填補
        mHeap.remove(size - 1);                // 刪除最後的元素

        if (mHeap.size() > 1)
            filterdown(index, mHeap.size()-1);    // 從index號位置開始自上向下調整為最小堆

        return 0;
    }

    /*
     * 最小堆的向上調整演算法(從start開始向上直到0，調整堆)
     *
     * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
     *
     * 引數說明：
     *     start -- 被上調節點的起始位置(一般為陣列中最後一個元素的索引)
     */
    protected void filterup(int start) {
        int c = start;            // 當前節點(current)的位置
        int p = (c-1)/2;        // 父(parent)結點的位置 
        T tmp = mHeap.get(c);        // 當前節點(current)的大小

        while(c > 0) {
            int cmp = mHeap.get(p).compareTo(tmp);
            if(cmp <= 0)
                break;
            else {
                mHeap.set(c, mHeap.get(p));
                c = p;
                p = (p-1)/2;   
            }       
        }
        mHeap.set(c, tmp);
    }

    /* 
     * 將data插入到二叉堆中
     */
    public void insert(T data) {
        int size = mHeap.size();

        mHeap.add(data);    // 將"陣列"插在表尾
        filterup(size);        // 向上調整堆
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<mHeap.size(); i++)
            sb.append(mHeap.get(i) +" ");

        return sb.toString();
    }

    public static void main(String[] args) {
        int i;
        int a[] = {80, 40, 30, 60, 90, 70, 10, 50, 20};
        MinHeap<Integer> tree=new MinHeap<Integer>();

        System.out.printf("== 依次新增: ");
        for(i=0; i<a.length; i++) {
            System.out.printf("%d ", a[i]);
            tree.insert(a[i]);
        }

        System.out.printf("\n== 最 小 堆: %s", tree);

        i=15;
        tree.insert(i);
        System.out.printf("\n== 新增元素: %d", i);
        System.out.printf("\n== 最 小 堆: %s", tree);

        i=10;
        tree.remove(i);
        System.out.printf("\n== 刪除元素: %d", i);
        System.out.printf("\n== 最 小 堆: %s", tree);
        System.out.printf("\n");
    }
}

6.3 二叉堆的Java測試程式

測試程式已經包含在相應的實現檔案中了，這裡只說明執行結果。

最大堆(MaxHeap.java)的執行結果：

== 依次新增: 10 40 30 60 90 70 20 50 80 
== 最 大 堆: 90 80 70 60 40 30 20 10 50 
== 新增元素: 85
== 最 大 堆: 90 85 70 60 80 30 20 10 50 40 
== 刪除元素: 90
== 最 大 堆: 85 80 70 60 40 30 20 10 50

最小堆(MinHeap.java)的執行結果：

== 最 小 堆: 10 20 30 50 90 70 40 80 60 
== 新增元素: 15
== 最 小 堆: 10 15 30 50 20 70 40 80 60 90 
== 刪除元素: 10
== 最 小 堆: 15 20 30 50 90 70 40 80 60

PS. 二叉堆是”堆排序”的理論基石。以後講解演算法時會講解到”堆排序”，理解了”二叉堆”之後，”堆排序”就很簡單了

相關推薦

Java資料結構與演算法：堆

1. 堆的定義 設有n個數據元素的關鍵字為（k0、k1、…、kn-1），如果它們滿足以下的關係：ki<= k2i+1且ki<= k2i+2（或ki>= k2i+1且ki>= k2i+2）（i=0、1、…、(n-2)/2）則稱之為堆(He

常用資料結構與演算法：二叉堆(binary heap)

一：什麼是二叉堆 二：二叉堆的實現  三：使用二叉堆的幾個例子 一：什麼是二叉堆 1.1：二叉堆簡介       二叉堆故名思議是一種特殊的堆，二叉堆具有堆的性質（父節點的鍵值總是大於或等於（小於或等於）任何一個子節點的鍵值），二叉堆又具有二叉樹的性質（二叉堆是完全二叉樹

資料結構與演算法：常用排序演算法總結

排序演算法穩定性的簡單形式化定義為：如果Ai = Aj，排序前Ai在Aj之前，排序後Ai還在Aj之前，則稱這種排序演算法是穩定的。通俗地講就是保證排序前後兩個相等的數的相對順序不變。 　　對於不穩定的排序演算法，只要舉出一個例項，即可說明它的不穩定性；而對於穩定的排序演算法，必須對演算

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

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

Java 資料結構與演算法------紅黑樹

資料結構的本質是：先存資料，然後在用的時候 前面一篇文章介紹了2-3查詢樹，2-3查詢樹能保證在插入元素之後能保證樹的平衡狀態，最壞情況下即所有的子節點都是2-node，樹的高度為lgN，從而保證了最壞情況下的時間複雜度，但是2-3樹實現起來比較複雜，本文介紹一種簡單實現2-3樹的資料結構

java資料結構與演算法_____選擇排序

import java.util.Arrays; /** * @author God *選擇排序（Selection sort）是一種簡單直觀的排序演算法。 *它的工作原理是每一次從待排序的資料元素中選出最小（或最大）的一個元素， *存放在序列的起始位置，直到全部待排序的資料元素排完

java資料結構與演算法____插入排序

import java.util.Arrays; /** * @author God * 有一個已經有序的資料序列，要求在這個已經排好的資料序列中插入一個數， * 但要求插入後此資料序列仍然有序，這個時候就要用到一種新的排序方法——插入排序法, * 插入排序的基本操作就是將一個數據插

資料結構與演算法：B+樹（B+Tree）介紹及其與B樹比較

定義 前面介紹了B樹及其基本操作，B+樹是B樹的一個變種。與B樹一樣，B+樹通常用於諸如資料庫和磁碟檔案系統等輔助儲存系統，輔助儲存系統一般容量大，但是資料存取速度比記憶體慢幾個數量級。B樹和B+樹結構減少輔存系統訪問次數，從而加快整體資料存取速度。兩者有一些共

Java資料結構與演算法（一）

一、學習資料結構與演算法的目的         預估程式在大量的資料集上執行時需要的時間成本和空間成本。 二、遞迴簡介          遞迴的四條基本法則：         一個簡單的遞迴案例：  三、實現泛型特性構建 pre-java5 1.引入泛

資料結構與演算法：B樹（B-Tree）定義及搜尋、插入、刪除基本操作

B樹（B-Tree） 在介紹什麼是B樹（B-Tree）之前，先看看為什麼存在B樹結構？ B樹（B-Tree）是為磁碟或者其他輔助儲存裝置而設計的一種平衡搜尋樹，如有的資料庫系統使用B樹或者B樹的變種來儲存資訊。B樹的節點可以有很多孩子，從數個到數千個，不同於一

java資料結構與演算法之平衡二叉樹(AVL樹)的設計與實現

關聯文章:   上一篇博文中，我們詳細地分析了樹的基本概念以及二叉查詢樹的實現過程，基於二叉查詢樹的特性，即對於樹種的每個結點T（T可能是父結點）,它的左子樹中所有項的值小T中的值，而它的右子樹中所有項的值都大於T中的值。這意味著該樹所有的元素可以用某

資料結構與演算法：關於野人過河問題的課程設計

野人過河問題 【問題描述】 有x個野人和y個傳教士來到河邊渡河，河岸有一條船，每次至多可供2人乘渡，野人和傳教士都會划船。在河岸，如果野人人數多於傳教士人數，則野人會吃掉傳教士。請設計一個程式來描述安全過河過程。 【基本要求】 （1）在河兩岸和船上要求野人的人數不大於傳教士的人數。 （2）要

資料結構與演算法： 快速排序

void quickSort(vector<int> &arra, int L, int R) { int *p; p = partition2(arra, L, R); cout << p[0] <<

資料結構與演算法： 排序1

1 氣泡排序 2 選擇排序 3 插入排序     #include <iostream> #include <vector> using namespace std; class Solution { public: //氣泡

Java資料結構和演算法：HashMap，雜湊表，雜湊函式

1. HashMap概述 HashMap是基於雜湊表的Map介面的非同步實現（Hashtable跟HashMap很像，唯一的區別是Hashtalbe中的方法是執行緒安全的，也就是同步的）。此實現提供所有可選的對映操作，並允許使用null值和null鍵。此類不保

資料結構與演算法：二叉樹

二叉樹是一種非常常見並且實用的資料結構，它結合了有序陣列與連結串列的優點。在二叉樹中查詢資料與在陣列中查詢資料一樣快，在二叉樹中新增、刪除資料的速度也和在連結串列中一樣高效，所以有關二叉樹的相關技術一直是程式設計師面試筆試中必考的知識點。 基礎知識 二叉樹（Bi

資料結構與演算法：快速排序

快速排序 快速排序（英語：Quicksort），又稱劃分交換排序（partition-exchange sort），通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行

資料結構與演算法 ：插入排序

插入排序 插入排序（英語：Insertion Sort）是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。

資料結構與演算法 ：選擇排序

選擇排序 選擇排序（Selection sort）是一種簡單直觀的排序演算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。 選擇排序

資料結構與演算法 ：氣泡排序

氣泡排序 氣泡排序（英語：Bubble Sort）是一種簡單的排序演算法。它重複地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”