[Python] 常見的排序與搜索算法

說明：

　　本文主要使用python實現常見的排序與搜索算法：冒泡排序、選擇排序、插入排序、希爾排序、快速排序、歸並排序以及二分查找等。

　　對算法的基本思想作簡要說明，只要理解了基本的思想，與實現語言無關。

　　本文主要參考網絡文章，僅供學習。

　　開發環境：Python3.5

　　

 

一、冒泡排序

　　冒泡排序（Bubble Sort）算是一種比較常見的排序算法，重復遍歷要排序的數列，一次比較相鄰的兩個元素，如果順序錯誤即互相交換位置，遍歷直到無需再交換，則此時數列已經排序完成。此算法名字由來：因為越小的元素（升序）經由交換慢慢 “浮”到數列的頂端。

　　1、冒泡排序的基本思想（運作原理）：

　　　   · 比較相鄰的元素，如果第一個比第二個大（升序），就交換它們兩個。

　　　　· 對每一對相鄰的元素作同樣的工作，從開始第一對到結尾最后一對，這一步做完后，最后的元素會是最大的數。

　　　　· 針對所有的元素重復以上的步驟，除了最后一個（倒數第二個與其已作比較）。

　　　　· 持續每次對越來越少的元素重復上面的步驟，知道沒有任何一對數字需要比較。

　　　　

　　　　交換過程示意圖（第一次）（來自網絡）：

　　　　

 

　　　　

　　2、python實現過程：

　　　　這里提供兩種實現過程，第二個實現過程為上面示意圖所示。　　

# coding=utf-8


def bubble_sort(ls):
    """冒泡排序"""
    print("before: ", ls)
    for i in range(0, len(ls) - 1):
        # i = [0, 1, ...., len(ls) - 2]，每次比較的第一個數的下標
        # j = [i + 1, i + 2, ..., len(ls) - 1]，每次比較的第二個數的下標
        for j in range(i + 1, len(ls)):
            if ls[i] > ls[j]:
                ls[i], ls[j] = ls[j], ls[i]
        print(ls)
    print("after: ", ls)


def bubble_sort2(ls):
    """冒泡排序"""
    print("before：", ls)
    for j in range(len(ls) - 1, 0, -1):
        # j = [len(ls) - 1, len(ls) - 2, ..., 1], 每次需要比較的次數
        # i = [0, 1, 2, ..., j - 1]，需要比較的下標
        for i in range(j):
            if ls[i] > ls[i + 1]:
                ls[i], ls[i + 1] = ls[i + 1], ls[i]
        print(ls)
    print("after：", ls)


if __name__ == "__main__":
    ls1 = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    ls2 = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    bubble_sort(ls1)
    print("-"*50)
    bubble_sort2(ls2)

　　　　

　　　　執行結果（分割線上為 bubble_sort1() 的執行結果，分割線下為 bubble_sort2() 的執行結果）：

　　　　

　　

　　3、時間復雜度：

　　　　最優時間復雜度：O(n)（表示遍歷一次發現沒有任何可以交換的元素排序結束，在內循環可以做一個標識判斷，如果首次循環沒有任何交換，則跳出）

　　　　最壞復雜度：O(n²)

　　　　穩定性：穩定

 

 

二、選擇排序

　　選擇排序（ Selection Sort ）是一種簡單直觀的排序算法，基本原理：首先在未排序中找到最小（大）的元素，存放在排序序列的起始位置，然后在從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序的末尾，一次類推，直到所有元素均排序完畢。

　　選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個唄移到其最終位置上，因此對 n 個元素的表進行排序共進行至多 n - 1次交換。在所有完成依靠交換去移動元素的排序方法中，選擇排序屬於非常好的一種。

　　

　　1、排序過程，圖示（圖來源網絡）：

　　　　假設右邊為已排序，然后從左邊未排序中選擇一個最大值，放到右邊來。

　　　　

　　　　　　

　　　

　　　

　　2、python實現過程：

　　　　這里代碼的思想為：假設左邊為已排序，右邊為排序。　　　

# coding=utf-8


def selection_sort(ls):
    """選擇排序"""
    # 假設左邊為已排序，右邊為未排序

    print("before：", ls)
    for i in range(0, len(ls) - 1):
        # i = [0, 1, 2,,, len(ls) - 2]
        # j = [i + 1, i + 2,,, len(ls) - 1]
        min_index = i
        for j in range(i + 1, len(ls)):
            if ls[j] < ls[min_index]:
                min_index = j

        if min_index != i:
            ls[min_index], ls[i] = ls[i], ls[min_index]
        print(ls)
    print("after：", ls)


if __name__ == "__main__":
    ls = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    selection_sort(ls)

　　　　

　　3、時間復雜度：

　　　　最優時間復雜度：O(n²)

　　　　最壞時間復雜度：O(n²)

　　　　穩定性：不穩定（考慮升序每次選擇最大的情況）

　　　　

 

三、插入排序

　　插入排序（Insert ion Sort），其工作原理：通過構建有序序列，對於未排序數據中從后向前掃描，找到相應位置並插入。插入排序在實現上，在從后面向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。

　　

　　1、排序過程，圖示意（圖片來自網絡）：

　　　　

 

　　　　　

　　　　

　　2、python實現過程：

　　　　從小標為 1 開始，往 0 遍歷，比較交換。

# coding=utf-8


def insert_sort(ls):
    """插入排序"""
    # 假設左邊已排序，右邊為未排序，每次從右邊取一個數，遍歷已排序的子序列，直到找到次數的位置。
    print("before: ", ls)
    for j in range(1, len(ls)):
        for i in range(j, 0, - 1):
            if ls[i] < ls[i - 1]:
                ls[i], ls[i - 1] = ls[i - 1], ls[i]
        print(ls)
    print("after: ", ls)


if __name__ == "__main__":
    ls = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    insert_sort(ls)

　　　　

　　　　執行結果：

　　　　

　　　　

　　3、時間復雜度：

　　　　最優時間復雜度：O(n)（升序序列，序列已經處於升序狀態）

　　　　最壞時間復雜度：O(n²)

　　　　穩定性：穩定

 

 

四、希爾排序

　　希爾排序（Shell Sort）是插入排序的一種。也稱為增量排序，是直接插入排序算法的一種更高效的改進版本。希爾排序是把紀錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨着增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至 1 時，整個序列恰被分成一組，算法便終止。

　　

　　1、希爾排序過程：

　　　　基本思想：將數組列在一個表中並對列分別進行插入排序，重復這過程，不過每次用更長的列（步長更長了，列數更少了）來進行。最后整個表就只有一列了。將數組轉換至表識為了更好理解這算法，算法本身還是使用數組進行排序。

　　　　例如，假設有這樣一組數[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長為5開始進行排序，我們可以通過將這列表放在有5列的表中進行更好的描述算法，這樣它們就應該看起來是這樣（豎着的元素是步長組成）：

　　　　

　　　　最后以 1 步長進行排序（此時就是簡單的插入排序）

　　　　　

　　　　

　　2、python實現過程：

　　　　實現過程基本和插入排序類似，只是插入排序的 step 固定為 1，而希爾排序的 step 會變化直至 為 1。

# coding=utf-8


def shell_sort(ls):
    """希爾排序"""
    print("before: ", ls)

    step = len(ls) // 2     # 初始步長

    while step > 0:
        # 插入排序
        for j in range(step, len(ls)):
            for i in range(j, 0, - step):
                if ls[i] < ls[i - step]:
                    ls[i], ls[i - step] = ls[i - step], ls[i]
        step //= 2
        print(ls)
    print("shell_sort ：", ls)


if __name__ == "__main__":
    ls = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    shell_sort(ls)

 

　　　　執行結果：

　　　　

 　

　　3、時間復雜度：

　　　　最優時間復雜度：根據步長序列的不同而不同。

　　　　最壞時間復雜度：O(n²)。

　　　　穩定性：不穩定。

　　　　

 

五、快速排序

　　快速排序（Quick Sort），又稱為划分交換排序（Partition-exchange Sort），通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要笑，然后在按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

　　

　　1、快速排序過程：

　　　　① 從數列中選出一個元素，稱為“基准”（pivot）。

　　　　② 重新排序數列，所有元素比基准值小的擺放在基准前面，所有元素比基准大的擺在基准的后面（相同的數，可以放到任意一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作。

　　　　③ 遞歸（recursive）把小於基准值元素子數列和大於基准值元素的子數列排序。

　　　　遞歸的的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。

 

　　　　

　　　　　

　　

　　2、python實現過程：

　　　　這里提供兩種快速排序的方式，基本思想一樣，第一種是在原有列表進行操作（通過游標進行），第二種則是新建左右子列表進行存儲。

# coding=utf-8


def quick_sort1(ls, start, end):
    """
        快速排序-1
        low 和 high 分別指向序列的頭和尾
        low += 1， high -= 1
        在low自增過程中，直到找到大於 mid_val 的下標
        在high自增減過程中，直到找到小於 mid_val 的小標
        然后將這兩個值交換
    """

    # 遞歸退出條件
    if start >= end:
        return

    low = start
    high = end
    mid_val = ls[low]

    while low < high:
        while low < high and ls[high] > mid_val:
            high -= 1
        ls[low] = ls[high]

        while low < high and ls[low] < mid_val:
            low += 1
        ls[high] = ls[low]

    ls[low] = mid_val

    print("mid:", mid_val, ls)

    quick_sort1(ls, start, low - 1)  # 左邊的子序列
    quick_sort1(ls, low + 1, end)    # 右邊的子序列

    return ls


def quick_sort2(ls):
    """快速排序-2"""

    # 遞歸退出條件
    if len(ls) <= 1:
        return ls

    left_ls, right_ls = [],[]
    mid_val = ls[0]
    for i in range(1, len(ls)):
        if ls[i] < mid_val:
            left_ls.append(ls[i])
        else:
            right_ls.append(ls[i])

    print(left_ls, mid_val, right_ls)

    # 遞歸調用，左右子列表
    left_res = quick_sort2(left_ls)
    right_res = quick_sort2(right_ls)

    return left_res + [mid_val] + right_res



if __name__ == "__main__":
    ls1 = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    ls2 = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    print("before：", ls1)
    res1 = quick_sort1(ls1, 0, len(ls1) - 1)
    print("quick sort1: ", res1)

    print("-"*50)
    print("before: ", ls2)
    res2 = quick_sort2(ls2)
    print("quick sort2：", res2)

 

　　　　執行結果：

　　　　　　

　　　　

　　3、時間復雜度：

　　　　最優時間復雜度：O(nlogn)

　　　　最壞時間復雜度：O(n²)

　　　　穩定性：不穩定

　　　　

 

 

六、歸並排序

　　歸並排序是采用分治法的一種非常典型的應用。歸並排序的思想就是先遞歸分解數組，再合並數組。

　　將數組分解最小之后，然后合並兩個有序數組，基本思路：比較兩個數組的最前面的數，誰小就先取誰，取了后相應的指針就往后移一位。然后再比較，直到一個數組為空，最后把另外一個數組的剩余部分復制過來即可。

 

　　1、歸並排序過程，圖示：

　　　　

　　　　

　　2、python實現過程：

　　　　先把序列拆分成 left_ls 和 right_ls ，然后再合並成一個res。

# coding=utf-8


def merge_sort(ls):
    """歸並排序"""
    n = len(ls)

    # 遞歸退出條件
    if n <= 1:
        return ls

    mid = n // 2

    # 1、拆分子序列
    left_ls = merge_sort(ls[:mid])
    right_ls = merge_sort(ls[mid:])

    # 2、合並子序列：left_ls 和 right_ls
    left_point, right_point = 0, 0
    res = []

    # 當left_ls或者right_ls 結束，就會退出 while，而另外一個則可能未結束，所有后面需要 res +=
    while left_point < len(left_ls) and right_point < len(right_ls):
        # 比較兩個子序列，小的先加入到 res[]
        if left_ls[left_point] < right_ls[right_point]:
            res.append(left_ls[left_point])
            left_point += 1
        else:
            res.append(right_ls[right_point])
            right_point += 1
    print("res:", res)

    res += left_ls[left_point:]
    res += right_ls[right_point:]

    return res


if __name__ == "__main__":
    ls = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    print("before: ", ls)
    res = merge_sort(ls)
    print("merge sort: ", res)

　　　　

　　　　執行結果：

　　　　　　

 

　　3、時間復雜度：

　　　　最優時間復雜度：O(nlogn)

　　　　最壞時間復雜度：O(nlogn)

　　　　穩定性：穩定

 

 

七、二分查找

　　二分查找又稱折半查找，優點是比較次數少，查找速度快，平均性能好，其缺點是要求待查找表為有序表，且插入刪除困難。因此，折半查找方法適用於不經常變動而查找頻繁的有序列表。

　　基本思想：假設表中元素是按升序排序，將表中間位置記錄關鍵字與查找關鍵字比較，如果兩者相等，則查找成功，否則利用中間位置記錄分成前、后兩個子表，如果中間位置記錄的關鍵字大於查找關鍵字，則進一步查找前一子表，否則進一步查找后一個子表。重復以上過程，知道找到滿足條件的記錄，使查找成功，或直到子表不存在為止，此時查找不成功。

　　

　　1、二分查找過程，圖示（圖片來源網絡）：

　　　　

　　　　

　　2、python實現過程：

　　　　這里主要兩種實現方式，一種遞歸，另一種非遞歸。

# coding=utf-8


def binary_search_recursion(ls, item):
    """二分查找---遞歸"""
    n = len(ls)
    if n < 1:
        return False

    mid = n // 2

    # 與中間值比較
    if item == ls[mid]:
        return True

    # 去左邊子序列查找
    elif item < ls[mid]:
        return binary_search_recursion(ls[:mid], item)

    # 去右邊子序列查找
    else:
        return binary_search_recursion(ls[mid + 1:], item)


def binary_search(ls, item):
    """二分查找---非遞歸"""
    n = len(ls)
    start = 0
    end = n - 1

    while start <= end:
        mid = (start + end) // 2

        if item == ls[mid]:
            return True
        elif item < ls[mid]:
            end = mid - 1
        else:
            start = mid + 1
    return False


if __name__ == "__main__":
    ls = [17, 20, 26, 31, 44, 54, 55, 77, 93]

    num = int(input("請輸入一個整數:"))
    res = binary_search(ls, num)
    print("查找結果：", res)

 

 

八、完整代碼

# coding=utf-8


def bubble_sort(ls):
    """冒泡排序"""
    print("before: ", ls)
    for i in range(0, len(ls) - 1):
        # i = [0, 1, ...., len(ls) - 2]，每次比較的第一個數的下標
        # j = [i + 1, i + 2, ..., len(ls) - 1]，每次比較的第二個數的下標
        for j in range(i + 1, len(ls)):
            if ls[i] > ls[j]:
                ls[i], ls[j] = ls[j], ls[i]
        print(ls)
    print("after: ", ls)


def bubble_sort2(ls):
    """冒泡排序"""
    print("before：", ls)
    for j in range(len(ls) - 1, 0, -1):
        # j = [len(ls) - 1, len(ls) - 2, ..., 1], 每次需要比較的次數
        # i = [0, 1, 2, ..., j - 1]，需要比較的下標
        for i in range(j):
            if ls[i] > ls[i + 1]:
                ls[i], ls[i + 1] = ls[i + 1], ls[i]
        print(ls)
    print("after：", ls)


def selection_sort(ls):
    """選擇排序"""
    # 假設左邊為已排序，右邊為未排序

    print("before：", ls)
    for i in range(0, len(ls) - 1):
        # i = [0, 1, 2,,, len(ls) - 2]
        # j = [i + 1, i + 2,,, len(ls) - 1]
        min_index = i
        for j in range(i + 1, len(ls)):
            if ls[j] < ls[min_index]:
                min_index = j

        if min_index != i:
            ls[min_index], ls[i] = ls[i], ls[min_index]
        print(ls)
    print("after：", ls)


def insert_sort(ls):
    """插入排序"""
    # 假設左邊已排序，右邊為未排序，每次從右邊取一個數，遍歷已排序的子序列，直到找到次數的位置。
    print("before: ", ls)
    for j in range(1, len(ls)):
        for i in range(j, 0, - 1):
            if ls[i] < ls[i - 1]:
                ls[i], ls[i - 1] = ls[i - 1], ls[i]
        print(ls)
    print("after: ", ls)


def shell_sort(ls):
    """希爾排序"""
    print("before: ", ls)

    step = len(ls) // 2     # 初始步長

    while step > 0:
        # 插入排序
        for j in range(step, len(ls)):
            for i in range(j, 0, - step):
                if ls[i] < ls[i - step]:
                    ls[i], ls[i - step] = ls[i - step], ls[i]
        step //= 2
        print(ls)
    print("shell_sort ：", ls)


def quick_sort1(ls, start, end):
    """
        快速排序-1
        low 和 high 分別指向序列的頭和尾
        low += 1， high -= 1
        在low自增過程中，直到找到大於 mid_val 的下標
        在high自增減過程中，直到找到小於 mid_val 的小標
        然后將這兩個值交換
    """

    # 遞歸退出條件
    if start >= end:
        return

    low = start
    high = end
    mid_val = ls[low]

    while low < high:
        while low < high and ls[high] > mid_val:
            high -= 1
        ls[low] = ls[high]

        while low < high and ls[low] < mid_val:
            low += 1
        ls[high] = ls[low]

    ls[low] = mid_val

    print("mid:", mid_val, ls)

    quick_sort1(ls, start, low - 1)  # 左邊的子序列
    quick_sort1(ls, low + 1, end)    # 右邊的子序列

    return ls


def quick_sort2(ls):
    """快速排序-2"""

    # 遞歸退出條件
    if len(ls) <= 1:
        return ls

    left_ls, right_ls = [],[]
    mid_val = ls[0]
    for i in range(1, len(ls)):
        if ls[i] < mid_val:
            left_ls.append(ls[i])
        else:
            right_ls.append(ls[i])

    print(left_ls, mid_val, right_ls)

    # 遞歸調用，左右子列表
    left_res = quick_sort2(left_ls)
    right_res = quick_sort2(right_ls)

    return left_res + [mid_val] + right_res


def merge_sort(ls):
    """歸並排序"""
    n = len(ls)

    # 遞歸退出條件
    if n <= 1:
        return ls

    mid = n // 2

    # 1、拆分子序列
    left_ls = merge_sort(ls[:mid])
    right_ls = merge_sort(ls[mid:])

    # 2、合並子序列：left_ls 和 right_ls
    left_point, right_point = 0, 0
    res = []

    # 當left_ls或者right_ls 結束，就會退出 while，而另外一個則可能未結束，所有后面需要 res +=
    while left_point < len(left_ls) and right_point < len(right_ls):
        # 比較兩個子序列，小的先加入到 res[]
        if left_ls[left_point] < right_ls[right_point]:
            res.append(left_ls[left_point])
            left_point += 1
        else:
            res.append(right_ls[right_point])
            right_point += 1
    print("res:", res)

    res += left_ls[left_point:]
    res += right_ls[right_point:]

    return res


def binary_search_recursion(ls, item):
    """二分查找---遞歸"""
    n = len(ls)
    if n < 1:
        return False

    mid = n // 2

    # 與中間值比較
    if item == ls[mid]:
        return True

    # 去左邊子序列查找
    elif item < ls[mid]:
        return binary_search_recursion(ls[:mid], item)

    # 去右邊子序列查找
    else:
        return binary_search_recursion(ls[mid + 1:], item)


def binary_search(ls, item):
    """二分查找---非遞歸"""
    n = len(ls)
    start = 0
    end = n - 1

    while start <= end:
        mid = (start + end) // 2

        if item == ls[mid]:
            return True
        elif item < ls[mid]:
            end = mid - 1
        else:
            start = mid + 1
    return False