摘要：在程式設計裡，排序是一個重要演算法，它可以幫助我們更快、更容易地定位資料。在這篇文章中，我們將使用排序演算法分類器對我們的陣列進行排序，瞭解它們是如何工作的。

本文分享自華為雲社群《Python 排序演算法指南》，原文作者：唐裡 。

在程式設計裡，排序是一個重要演算法，它可以幫助我們更快、更容易地定位資料。在這篇文章中，我們將使用排序演算法分類器對我們的陣列進行排序，瞭解它們是如何工作的。為了保障本文的可讀性，這裡只著重介紹4個排序演算法。

• 氣泡排序
• 插入排序.
• 歸併排序.
• 快速排序

氣泡排序

氣泡排序是一種簡單的排序演算法，它比較兩個相鄰物件的順序，將非預期順序的相鄰物件位置交換。下面是它的工作步驟：

• 比較第一個和第二個物件，如果第一個大於第二個，將之交換。
• 將第二個物件和第三個物件進行比較，檢查相同條件。以此類推直到比較到陣列最後一個數。
• 重複執行這個過程，這樣陣列就按照從左到右從小到大排列了。

程式碼如下

# Python中的氣泡排序
def bubbleSort(array):
 
  # 外迴圈訪問陣列的每個元素
  for i in range(len(array)):

    # 內迴圈將陣列元素與外迴圈迭代元素進行比較
    for j in range(0, len(array) - i - 1):

      # 比較兩個相鄰元素
      
 
if array[j] > array[j + 1]:

        # 如果元素不是預期順序則交換元素
        temp = array[j]
        array[j] = array[j+1]
        array[j+1] = temp
data = [5, 4, 3, 2, 1]

bubbleSort(data)
print('Sorted Array')
print(data)

#output: [1, 2, 3, 4, 5]

插入排序

插入排序也很簡單，它分為已經排序和未排序兩部分，將未排序部分的元素選中後正確放置在排序部分即可。類似卡牌遊戲時我們手裡有分類卡。下面是它的工作步驟：

• 遍歷陣列查詢最低元素的索引並將其與陣列的第一個元素交換。
• 找到陣列(不包括第一個元素)中另一個最低的元素，並將其與第二個元素交換 ，然後重複操作，直到陣列的最後一個元素。
• 這樣，陣列中最低的元素都會移到左邊，而最大的元素會在陣列的右邊，因此陣列是有序的。

程式碼如下

# Python中的排序演算法
def insertionSort(array):
    for step in range(1, len(array)):
        key = array[step]
        j = step - 1
        # 將鍵與其左側的每個元素進行比較，直到找到小於它的元素
        while j >= 0 and key < array[j]:
            array[j + 1] = array[j]
            j = j - 1
        # 將鍵放在比它小的元素之後。
        array[j + 1] = key

data = [11, 4, 3, 2, 12]

insertionSort(data)
print("sorted array")
print(data)

#output: [2, 3, 4, 11, 12]

歸併排序

歸併排序是基於分治演算法原理的最常用的排序演算法。我們將陣列分為多個部分，然後對他們進行排序，最後將子部分合併為一個排序陣列，為了更好的理解，下面是它的工作步驟：

• 把陣列分成小塊，直到每一塊中沒有單獨的元素。
• 比較每一塊陣列，將最小值放在左側，最大值放在陣列的右側。
• 如果覺得很難理解，看看這個動圖。

程式碼如下

# Python的歸併排序
def mergeSort(array):
    if len(array) > 1:

        #  r 是將陣列分為兩半後的分割點
        r = len(array)//2
        L = array[:r]
        M = array[r:]

        # 通過遞迴方法對兩半進行排序
        mergeSort(L)
        mergeSort(M)

        i = j = k = 0

        # 直到我們到達 L 或 M 的任一端，從中選擇較大的元素 L 和 M 並將它們放置在 A[p 到 r] 處的正確位置
        while i < len(L) and j < len(M):
            if L[i] < M[j]:
                array[k] = L[i]
                i += 1
            else:
                array[k] = M[j]
                j += 1
            k += 1

        # 將L或者M裡的元素排序好後，將剩餘的元素並放入 A[p to r]
        while i < len(L):
            array[k] = L[i]
            i += 1
            k += 1

        while j < len(M):
            array[k] = M[j]
            j += 1
            k += 1
array = [8, 6, 14, 12, 10, 3]

mergeSort(array)
print("Sorted array: ")
print(array)

#output: [3, 6, 8, 10, 12, 14]

快速排序

與歸併排序一樣，快速排序也是基於分治演算法的原理的一種排序演算法。它選擇一個元素作為樞軸，並圍繞樞軸分割槽陣列。下面是它的工作步驟：

• 選擇一個轉折點，這可以是隨機選擇的。這裡假設我們選擇陣列的最後一個元素作為軸心。
• 將所有小於軸心的專案放在左側，大於軸心的專案放在陣列右側。
• 在樞軸的左右兩側重複上面的步驟。

# Python中的快速排序
# 找到分割槽位置
def partition(array, lowest, highest):

  # 這裡我們選擇最右的元素作為樞軸
  pivot = array[highest]

  # 為最大的元素設定指標
  i = lowest - 1
  # 將每個元素與樞軸元素對比
  for j in range(lowest, highest):
    if array[j] <= pivot:
      i = i + 1
      # 將 i 處的元素與 j 處的元素交換
      (array[i], array[j]) = (array[j], array[i])

  # 將樞軸元素與 i 指定的較大元素交換
  (array[i + 1], array[highest]) = (array[highest], array[i + 1])

  # 返回分割槽完成的位置
  return i + 1
def quickSort(array, lowest, highest):
  if lowest < highest:

     # 找到樞軸元素
     # 小於樞軸的元素放左邊
     # 大於樞軸的元素放右邊
    pi = partition(array, lowest, highest)

    # 樞軸左側的遞迴呼叫
    quickSort(array, lowest, pi - 1)

    # 樞軸右側的遞迴呼叫
    quickSort(array, pi + 1, highest)
array = [9, 8, 3, 2, 1, 10, 7, 6, 19]

size = len(array)
quickSort(array, 0, size - 1)
print('Sorted Array is below')
print(array)

#output [1, 2, 3, 6, 7, 8, 9, 10, 19]

以上就是本文的全部內容，感謝閱讀，如果對你有幫助希望點個贊~

原文地址：https://python.plainenglish.io/a-guide-to-sorting-algorithms-in-python-dfa9436b8527

點選關注，第一時間瞭解華為雲新鮮技術~