在編程里，排序是一個重要算法，它可以幫助我們更快、更容易地定位數(shù)據(jù)。在這篇文章中，我們將使用排序算法分類器對我們的數(shù)組進行排序，了解它們是如何工作的。為了保障本文的可讀性，這里只著重介紹4個排序算法。

• 冒泡排序
• 插入排序.
• 歸并排序.
• 快速排序

冒泡排序

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

• 比較第一個和第二個對象，如果第一個大于第二個，將之交換。
• 將第二個對象和第三個對象進行比較，檢查相同條件。以此類推直到比較到數(shù)組最后一個數(shù)。
• 重復執(zhí)行這個過程，這樣數(shù)組就按照從左到右從小到大排列了。

# Python中的冒泡排序 
def bubbleSort(array): 
  
  # 外循環(huán)訪問數(shù)組的每個元素 
  for i in range(len(array)): 
 
    # 內(nèi)循環(huán)將數(shù)組元素與外循環(huán)迭代元素進行比較 
    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] 

插入排序

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

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

代碼如下：

# 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] 

歸并排序

歸并排序是基于分治算法原理的最常用的排序算法。我們將數(shù)組分為多個部分，然后對他們進行排序，最后將子部分合并為一個排序數(shù)組，為了更好的理解，下面是它的工作步驟：

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

代碼如下：

# Python的歸并排序 
def mergeSort(array): 
    if len(array) > 1: 
 
        #  r 是將數(shù)組分為兩半后的分割點 
        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] 

快速排序

與歸并排序一樣，快速排序也是基于分治算法的原理的一種排序算法。它選擇一個元素作為樞軸，并圍繞樞軸分區(qū)數(shù)組。下面是它的工作步驟：

• 選擇一個轉折點，這可以是隨機選擇的。這里假設我們選擇數(shù)組的最后一個元素作為軸心。
• 將所有小于軸心的項目放在左側，大于軸心的項目放在數(shù)組右側。
• 在樞軸的左右兩側重復上面的步驟。

# Python中的快速排序 
# 找到分區(qū)位置 
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]) 
 
  # 返回分區(qū)完成的位置 
  return i + 1 
def quickSort(array, lowest, highest): 
  if lowest < highest: 
 
     # 找到樞軸元素 
     # 小于樞軸的元素放左邊 
     # 大于樞軸的元素放右邊 
    pi = partition(array, lowest, highest) 
 
    # 樞軸左側的遞歸調(diào)用 
    quickSort(array, lowest, pi - 1) 
 
    # 樞軸右側的遞歸調(diào)用 
    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]