這期內容當中小編將會給大家帶來有關使用python怎么實現一個經典排序算法，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

目前創新互聯已為上1000+的企業提供了網站建設、域名、雅安服務器托管、綿陽服務器托管、企業網站設計、林甸網站維護等服務，公司將堅持客戶導向、應用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協力一起成長，共同發展。

冒泡排序

內層循環中相鄰的元素被依次比較，內層循環第一次結束后會將較大的元素移到序列最右邊，第二次結束后會將次大的元素移到較大元素的左邊，每次內層循環結束都會將一個元素排好序。

def bubble_sort(arr):
  length = len(arr)
  for i in range(length):
    for j in range(length - i - 1):
      if arr[j] > arr[j + 1]:
        arr[j], arr[j + 1] = arr[j + 1], arr[j]
  return arr

選擇排序

每次內層循環都會得到一個當前最小的元素，并將其放到合適的位置。內層循環第一次結束后會將最小的元素交換到序列首位，第二次結束后會將第二小的元素交換到序列第二位，每次內層循環結束后都會將一個元素放在正確的順序位置。

def selection_sort(arr):
  length = len(arr)
  for i in range(length):
    min_index = i
    for j in range(i + 1, length):
      if arr[j] < arr[min_index]:
        min_index = j
    arr[i], arr[min_index] = arr[min_index], arr[i]
  return arr

插入排序

類比玩撲克牌時理牌的思想，從第一個元素開始，假設它是已經排好序的。然后開始處理第二個元素，如果比第一個元素小，則將其放到第一個元素左邊，否則放在其右邊，那么現在前兩個元素以及排好序了，之后再依次處理剩余的元素。

def insertion_sort(arr):
  length = len(arr)
  for i in range(1, length):
    pre = i - 1
    current_value = arr[i]
    while pre >= 0 and arr[pre] > current_value:
      arr[pre + 1] = arr[pre]
      pre -= 1
    arr[pre+1] = current_value
  return arr

希爾排序

希爾排序就是將插入排序的改進版本。插入排序中每次逐步比較元素，而希爾排序中則是從一個較大的步數開始比較，最后減小到一步。

def shell_sort(arr):
  length = len(arr)
  gap = length // 2
  while gap > 0:
    for i in range(gap, length):
      pre = i - gap
      current_value = arr[i]
      while pre >= 0 and arr[pre] > current_value:
        arr[pre + gap] = arr[pre]
        pre -= gap
      arr[pre + gap] = current_value
    gap = gap // 2
  return arr

歸并排序

先將序列前半部分排好序，再將序列后半部分排好序，之后再將這兩部分合并得到最終的序列，具體實現為遞歸地將序列分為兩部分，分別排序后再合并。

def merge(left, right):
  result = []
  while len(left) > 0 and len(right) > 0:
    if left[0] < right[0]:
      result.append(left.pop(0))
    else:
      result.append(right.pop(0))
  if len(left) > 0:
    result.extend(left[:])
  if len(right) > 0:
    result.extend(right[:])
  return result


def merge_sort(arr):
  if len(arr) < 2:
    return arr
  middle = len(arr) // 2
  return merge(merge_sort(arr[:middle]), merge_sort(arr[middle:]))

快速排序

取一個元素，將比它小的元素都移到它左側，將比它大的元素都移到它右側，并遞歸地處理它左側的序列和右側的序列。

def partition(arr, left=None, right=None):
  pivot = left
  index = pivot + 1
  for i in range(index, right + 1):
    if arr[i] < arr[pivot]:
      arr[i], arr[index] = arr[index], arr[i]
      index += 1
  arr[pivot], arr[index - 1] = arr[index - 1], arr[pivot]
  return index - 1


def quick_sort(arr, left=None, right=None):
  left = 0 if left is None else left
  right = len(arr) - 1 if right is None else right
  if left < right:
    partition_index = partition(arr, left, right)
    quick_sort(arr, left, partition_index - 1)
    quick_sort(arr, partition_index + 1, right)
  return arr

堆排序

首先構建一個較大堆，較大堆的性質是父節點的值總是大于其左右子節點的值，那么此時根節點的值是較大的，則將其移到序列的最右邊。之后將堆中當前最后一個葉節點移到根節點上，因為這可能會不符合較大堆的性質，所以會進行調整，將它與其左右子節點中較大的值進行交換，則相當于將葉節點向下移動，交換過后如果還是不符合性質，則繼續進行交換，直到符合性質后，此時的根節點的值就是當前堆中的較大值，將其取出放入序列中正確的位置后繼續上述流程處理剩下的節點。

global length3


def heapify(arr, i):
  left = 2 * i + 1
  right = 2 * i + 2
  largest = i
  if left < length3 and arr[left] > arr[largest]:
    largest = left
  if right < length3 and arr[right] > arr[largest]:
    largest = right
  if largest != i:
    arr[i], arr[largest] = arr[largest], arr[i]
    heapify(arr, largest)


def build_max_heap(arr):
  for i in range(len(arr) // 2, -1, -1):
    heapify(arr, i)


def heap_sort(arr):
  global length3
  length3 = len(arr)
  build_max_heap(arr)
  for i in range(len(arr) - 1, 0, -1):
    arr[0], arr[i] = arr[i], arr[0]
    length3 -= 1
    heapify(arr, 0)
  return arr

計數排序

將序列中的元素按照其值放入相應的桶中，之后再按照桶的順序取出即可，計數排序不需要比較操作。

def counting_sort(arr):
  max_value = max(arr)
  buckets = [0] * (max_value + 1)
  index = 0
  length = len(arr)
  for i in range(length):
    buckets[arr[i]] += 1
  for j in range(max_value + 1):
    while buckets[j] > 0:
      arr[index] = j
      index += 1
      buckets[j] -= 1
  return arr

桶排序

類別計數排序，構造很多桶，但每個桶中能放入值在特定范圍內的元素，將序列中的元素按照要求放入各個桶中，再將每個桶中的元素進行排序，最后按照桶的順序和各個桶中元素的順序得到最終序列。

def bucket_sort(arr):
  bucket_size = 5
  max_value = max(arr)
  min_value = min(arr)
  bucket_num = (max_value - min_value) // bucket_size + 1
  buckets = {i: [] for i in range(bucket_num)}
  for i in range(len(arr)):
    buckets[(arr[i] - min_value) // bucket_size].append(arr[i])
  result = []
  for i in range(bucket_num):
    insertion_sort(buckets[i])
    result.extend(buckets[i])
  return result

基數排序

按照元素值的特定位進行排序，從低位到高位分別進行排序。

def radix_sort(arr):
  max_value = max(arr)
  max_digit = len(str(max_value))
  dev = 1
  mod = 10
  result = arr[:]
  for i in range(max_digit):
    buckets = {i: [] for i in range(mod)}
    for k in range(len(result)):
      key = (result[k] % mod) // dev
      buckets[key].append(result[k])
    result = []
    for j in range(mod):
      result.extend(buckets[j])
    dev *= 10
    mod *= 10
  return result

上述就是小編為大家分享的使用python怎么實現一個經典排序算法了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注創新互聯行業資訊頻道。

新聞標題：使用python怎么實現一個經典排序算法-創新互聯
文章位置：http://www.yijiale78.com/article14/ddcige.html

成都網站建設公司_創新互聯，為您提供企業網站制作、網站排名、品牌網站設計、標簽優化、營銷型網站建設、網站內鏈

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯