數據結構常見的八大排序算法

原創 夜空中de一颗星 2018-08-24 17:15


數據結構常見的八大排序算法

原文鏈接：http://www.jianshu.com/p/7d037c332a9d
數據結構常見的八大排序算法的 Python 代碼實現。 —— 由醋分享

前言

八大排序，三大查找是《數據結構》當中非常基礎的知識點，在這裏爲了複習順帶總結了一下常見的八種排序算法。
常見的八大排序算法，他們之間關係如下：


排序算法.png


他們的性能比較：


性能比較.png


下面，利用Python分別將他們進行實現。

直接插入排序

  • 算法思想：

直接插入排序.gif


直接插入排序的核心思想就是：將數組中的所有元素依次跟前面已經排好的元素相比較，如果選擇的元素比已排序的元素小，則交換，直到全部元素都比較過。
因此，從上面的描述中我們可以發現，直接插入排序可以用兩個循環完成：

  1. 第一層循環：遍歷待比較的所有數組元素
  2. 第二層循環：將本輪選擇的元素(selected)與已經排好序的元素(ordered)相比較。
    如果：selected > ordered，那麼將二者交換
  • 代碼實現 
    #直接插入排序
def insert_sort(L):
  #遍歷數組中的所有元素，其中0號索引元素默認已排序，因此從1開始
  for x in range(1,len(L)):
  #將該元素與已排序好的前序數組依次比較，如果該元素小，則交換
  #range(x-1,-1,-1):從x-1倒序循環到0
      for i in range(x-1,-1,-1):
  #判斷：如果符合條件則交換
          if L[i] > L[i+1]:
              temp = L[i+1]
              L[i+1] = L[i]
              L[i] = temp

希爾排序

  • 算法思想：

希爾排序.png


希爾排序的算法思想：將待排序數組按照步長gap進行分組，然後將每組的元素利用直接插入排序的方法進行排序；每次將gap折半減小，循環上述操作；當gap=1時，利用直接插入，完成排序。
同樣的：從上面的描述中我們可以發現：希爾排序的總體實現應該由三個循環完成：

  1. 第一層循環：將gap依次折半，對序列進行分組，直到gap=1
  2. 第二、三層循環：也即直接插入排序所需要的兩次循環。具體描述見上。
  • 代碼實現： 
    #希爾排序
def insert_shell(L):
  #初始化gap值，此處利用序列長度的一般爲其賦值
  gap = (int)(len(L)/2)
  #第一層循環：依次改變gap值對列表進行分組
  while (gap >= 1):
  #下面：利用直接插入排序的思想對分組數據進行排序
  #range(gap,len(L)):從gap開始
      for x in range(gap,len(L)):
  #range(x-gap,-1,-gap):從x-gap開始與選定元素開始倒序比較，每個比較元素之間間隔gap
          for i in range(x-gap,-1,-gap):
  #如果該組當中兩個元素滿足交換條件，則進行交換
              if L[i] > L[i+gap]:
                  temp = L[i+gap]
                  L[i+gap] = L[i]
                  L[i] =temp
  #while循環條件折半
      gap = (int)(gap/2)

簡單選擇排序

  • 算法思想

簡單選擇排序.gif


簡單選擇排序的基本思想：比較+交換。

  1. 從待排序序列中，找到關鍵字最小的元素；
  2. 如果最小元素不是待排序序列的第一個元素，將其和第一個元素互換；
  3. 從餘下的 N - 1 個元素中，找出關鍵字最小的元素，重複(1)、(2)步，直到排序結束。
    因此我們可以發現，簡單選擇排序也是通過兩層循環實現。
    第一層循環：依次遍歷序列當中的每一個元素
    第二層循環：將遍歷得到的當前元素依次與餘下的元素進行比較，符合最小元素的條件，則交換。
  • 代碼實現 
    # 簡單選擇排序
def select_sort(L):
#依次遍歷序列中的每一個元素
  for x in range(0,len(L)):
#將當前位置的元素定義此輪循環當中的最小值
      minimum = L[x]
#將該元素與剩下的元素依次比較尋找最小元素
      for i in range(x+1,len(L)):
          if L[i] < minimum:
              temp = L[i];
              L[i] = minimum;
              minimum = temp
#將比較後得到的真正的最小值賦值給當前位置
      L[x] = minimum

堆排序

  • 堆的概念
    堆：本質是一種數組對象。特別重要的一點性質：任意的葉子節點小於（或大於）它所有的父節點。對此，又分爲大頂堆和小頂堆，大頂堆要求節點的元素都要大於其孩子，小頂堆要求節點元素都小於其左右孩子，兩者對左右孩子的大小關係不做任何要求。
    利用堆排序，就是基於大頂堆或者小頂堆的一種排序方法。下面，我們通過大頂堆來實現。

  • 基本思想：
    堆排序可以按照以下步驟來完成：

    1. 首先將序列構建稱爲大頂堆；
      （這樣滿足了大頂堆那條性質：位於根節點的元素一定是當前序列的最大值）

      構建大頂堆.png
    2. 取出當前大頂堆的根節點，將其與序列末尾元素進行交換；
      （此時：序列末尾的元素爲已排序的最大值；由於交換了元素，當前位於根節點的堆並不一定滿足大頂堆的性質）
    3. 對交換後的n-1個序列元素進行調整，使其滿足大頂堆的性質；

      Paste_Image.png
    4. 重複2.3步驟，直至堆中只有1個元素爲止

  • 代碼實現：

    #-------------------------堆排序--------------------------------
#**********獲取左右葉子節點**********
def LEFT(i):
  return 2*i + 1
def RIGHT(i):
  return 2*i + 2
#********** 調整大頂堆 **********
#L:待調整序列 length: 序列長度 i:需要調整的結點
def adjust_max_heap(L,length,i):
#定義一個int值保存當前序列最大值的下標
  largest = i
#執行循環操作：兩個任務：1 尋找最大值的下標；2.最大值與父節點交換
  while (1):
#獲得序列左右葉子節點的下標
      left,right = LEFT(i),RIGHT(i)
#當左葉子節點的下標小於序列長度 並且 左葉子節點的值大於父節點時，將左葉子節點的下標賦值給largest
      if (left < length) and (L[left] > L[i]):
          largest = left
          print('左葉子節點')
      else:
          largest = i
#當右葉子節點的下標小於序列長度 並且 右葉子節點的值大於父節點時，將右葉子節點的下標值賦值給largest
      if (right < length) and (L[right] > L[largest]):
          largest = right
          print('右葉子節點')
#如果largest不等於i 說明當前的父節點不是最大值，需要交換值
      if (largest != i):
          temp = L[i]
          L[i] = L[largest]
          L[largest] = temp
          i = largest
          print(largest)
          continue
      else:
          break
#********** 建立大頂堆 **********
def build_max_heap(L):
  length = len(L)
  for x in range((int)((length-1)/2),-1,-1):
      adjust_max_heap(L,length,x)
#********** 堆排序 **********
def heap_sort(L):
#先建立大頂堆，保證最大值位於根節點；並且父節點的值大於葉子結點
  build_max_heap(L)
#i：當前堆中序列的長度.初始化爲序列的長度
  i = len(L)
#執行循環：1. 每次取出堆頂元素置於序列的最後(len-1,len-2,len-3...)
#         2. 調整堆，使其繼續滿足大頂堆的性質，注意實時修改堆中序列的長度
  while (i > 0):
      temp = L[i-1]
      L[i-1] = L[0]
      L[0] = temp
#堆中序列長度減1
      i = i-1
#調整大頂堆
      adjust_max_heap(L,i,0)

冒泡排序

  • 基本思想

    冒泡排序.gif

    冒泡排序思路比較簡單：
    1. 將序列當中的左右元素，依次比較，保證右邊的元素始終大於左邊的元素；
      （ 第一輪結束後，序列最後一個元素一定是當前序列的最大值；）
    2. 對序列當中剩下的n-1個元素再次執行步驟1。
    3. 對於長度爲n的序列，一共需要執行n-1輪比較
      （利用while循環可以減少執行次數）

*代碼實現

#冒泡排序
def bubble_sort(L):
    length = len(L)
#序列長度爲length，需要執行length-1輪交換
    for x in range(1,length):
#對於每一輪交換，都將序列當中的左右元素進行比較
#每輪交換當中，由於序列最後的元素一定是最大的，因此每輪循環到序列未排序的位置即可
        for i in range(0,length-x):
            if L[i] > L[i+1]:
                temp = L[i]
                L[i] = L[i+1]
                L[i+1] = temp

快速排序

  • 算法思想：

    快速排序.gif

    快速排序的基本思想：挖坑填數+分治法
    1. 從序列當中選擇一個基準數(pivot)
      在這裏我們選擇序列當中第一個數最爲基準數
    2. 將序列當中的所有數依次遍歷，比基準數大的位於其右側，比基準數小的位於其左側
    3. 重複步驟1.2，直到所有子集當中只有一個元素爲止。
      用僞代碼描述如下：
      1．i =L; j = R; 將基準數挖出形成第一個坑a[i]。
      2．j--由後向前找比它小的數，找到後挖出此數填前一個坑a[i]中。
      3．i++由前向後找比它大的數，找到後也挖出此數填到前一個坑a[j]中。
      4．再重複執行2，3二步，直到i==j，將基準數填入a[i]中
  • 代碼實現： 
    #快速排序
#L：待排序的序列；start排序的開始index,end序列末尾的index
#對於長度爲length的序列：start = 0;end = length-1
def quick_sort(L,start,end):
  if start < end:
      i , j , pivot = start , end , L[start]
      while i < j:
#從右開始向左尋找第一個小於pivot的值
          while (i < j) and (L[j] >= pivot):
              j = j-1
#將小於pivot的值移到左邊
          if (i < j):
              L[i] = L[j]
              i = i+1 
#從左開始向右尋找第一個大於pivot的值
          while (i < j) and (L[i] < pivot):
              i = i+1
#將大於pivot的值移到右邊
          if (i < j):
              L[j] = L[i]
              j = j-1
#循環結束後，說明 i=j，此時左邊的值全都小於pivot,右邊的值全都大於pivot
#pivot的位置移動正確，那麼此時只需對左右兩側的序列調用此函數進一步排序即可
#遞歸調用函數：依次對左側序列：從0 ~ i-1//右側序列：從i+1 ~ end
      L[i] = pivot
#左側序列繼續排序
      quick_sort(L,start,i-1)
#右側序列繼續排序
      quick_sort(L,i+1,end)

歸併排序

  • 算法思想：


    歸併排序.gif
    1. 歸併排序是建立在歸併操作上的一種有效的排序算法，該算法是採用分治法的一個典型的應用。它的基本操作是：將已有的子序列合併，達到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。

    2. 歸併排序其實要做兩件事：

      • 分解----將序列每次折半拆分
      • 合併----將劃分後的序列段兩兩排序合併
        因此，歸併排序實際上就是兩個操作，拆分+合併

    3. 如何合併？
      L[first...mid]爲第一段，L[mid+1...last]爲第二段，並且兩端已經有序，現在我們要將兩端合成達到L[first...last]並且也有序。

      • 首先依次從第一段與第二段中取出元素比較，將較小的元素賦值給temp[]
      • 重複執行上一步，當某一段賦值結束，則將另一段剩下的元素賦值給temp[]
      • 此時將temp[]中的元素複製給L[]，則得到的L[first...last]有序

    4. 如何分解？
      在這裏，我們採用遞歸的方法，首先將待排序列分成A,B兩組；然後重複對A、B序列
      分組；直到分組後組內只有一個元素，此時我們認爲組內所有元素有序，則分組結束。

  • 代碼實現

    # 歸併排序
#這是合併的函數
# 將序列L[first...mid]與序列L[mid+1...last]進行合併
def mergearray(L,first,mid,last,temp):
#對i,j,k分別進行賦值
  i,j,k = first,mid+1,0
#當左右兩邊都有數時進行比較，取較小的數
  while (i <= mid) and (j <= last):
      if L[i] <= L[j]:
          temp[k] = L[i]
          i = i+1
          k = k+1
      else:
          temp[k] = L[j]
          j = j+1
          k = k+1
#如果左邊序列還有數
  while (i <= mid):
      temp[k] = L[i]
      i = i+1
      k = k+1
#如果右邊序列還有數
  while (j <= last):
      temp[k] = L[j]
      j = j+1
      k = k+1
#將temp當中該段有序元素賦值給L待排序列使之部分有序
  for x in range(0,k):
      L[first+x] = temp[x]
# 這是分組的函數
def merge_sort(L,first,last,temp):
  if first < last:
      mid = (int)((first + last) / 2)
#使左邊序列有序
      merge_sort(L,first,mid,temp)
#使右邊序列有序
      merge_sort(L,mid+1,last,temp)
#將兩個有序序列合併
      mergearray(L,first,mid,last,temp)
# 歸併排序的函數
def merge_sort_array(L):
#聲明一個長度爲len(L)的空列表
  temp = len(L)*[None]
#調用歸併排序
  merge_sort(L,0,len(L)-1,temp)

基數排序

  • 算法思想

    基數排序.gif
    1. 基數排序：通過序列中各個元素的值，對排序的N個元素進行若干趟的“分配”與“收集”來實現排序。
      分配：我們將L[i]中的元素取出，首先確定其個位上的數字，根據該數字分配到與之序號相同的桶中
      收集：當序列中所有的元素都分配到對應的桶中，再按照順序依次將桶中的元素收集形成新的一個待排序列L[ ]
      對新形成的序列L[]重複執行分配和收集元素中的十位、百位...直到分配完該序列中的最高位，則排序結束
    2. 根據上述“基數排序”的展示，我們可以清楚的看到整個實現的過程
  • 代碼實現 
    #************************基數排序****************************
#確定排序的次數
#排序的順序跟序列中最大數的位數相關
def radix_sort_nums(L):
  maxNum = L[0]
#尋找序列中的最大數
  for x in L:
      if maxNum < x:
          maxNum = x
#確定序列中的最大元素的位數
  times = 0
  while (maxNum > 0):
      maxNum = (int)(maxNum/10)
      times = times+1
  return times
#找到num從低到高第pos位的數據
def get_num_pos(num,pos):
  return ((int)(num/(10**(pos-1))))%10
#基數排序
def radix_sort(L):
  count = 10*[None]        #存放各個桶的數據統計個數
  bucket = len(L)*[None]  #暫時存放排序結果
#從低位到高位依次執行循環
  for pos in range(1,radix_sort_nums(L)+1):
      #置空各個桶的數據統計
      for x in range(0,10):
          count[x] = 0
      #統計當前該位(個位，十位，百位....)的元素數目
      for x in range(0,len(L)):
          #統計各個桶將要裝進去的元素個數
          j = get_num_pos(int(L[x]),pos)
          count[j] = count[j]+1
      #count[i]表示第i個桶的右邊界索引
      for x in range(1,10):
          count[x] = count[x] + count[x-1]
      #將數據依次裝入桶中
      for x in range(len(L)-1,-1,-1):
          #求出元素第K位的數字
          j = get_num_pos(L[x],pos)
          #放入對應的桶中，count[j]-1是第j個桶的右邊界索引
          bucket[count[j]-1] = L[x]
          #對應桶的裝入數據索引-1
          count[j] = count[j]-1
      # 將已分配好的桶中數據再倒出來，此時已是對應當前位數有序的表
      for x in range(0,len(L)):
          L[x] = bucket[x]

後記

寫完之後運行了一下時間比較：

  • 1w個數據時： 
    直接插入排序:11.615608
希爾排序:13.012008
簡單選擇排序:3.645136000000001
堆排序:0.09587900000000005
冒泡排序:6.687218999999999
#****************************************************
快速排序:9.999999974752427e-07 
#快速排序有誤：實際上並未執行
#RecursionError: maximum recursion depth exceeded in comparison
#****************************************************
歸併排序:0.05638299999999674
基數排序:0.08150400000000246
  • 10w個數據時： 
    直接插入排序:1233.581131
希爾排序:1409.8012320000003
簡單選擇排序:466.66974500000015
堆排序:1.2036720000000969
冒泡排序:751.274449
#****************************************************
快速排序:1.0000003385357559e-06
#快速排序有誤：實際上並未執行
#RecursionError: maximum recursion depth exceeded in comparison
#****************************************************
歸併排序:0.8262230000000272
基數排序:1.1162899999999354
    從運行結果上來看，堆排序、歸併排序、基數排序真的快。
    對於快速排序迭代深度超過的問題，可以將考慮將快排通過非遞歸的方式進行實現。

參考資料

數據結構常見的八大排序算法

閱讀 1432
收藏 210
2017-04-30
原文鏈接：http://www.jianshu.com/p/7d037c332a9d
數據結構常見的八大排序算法的 Python 代碼實現。 —— 由醋分享

前言

八大排序，三大查找是《數據結構》當中非常基礎的知識點，在這裏爲了複習順帶總結了一下常見的八種排序算法。
常見的八大排序算法，他們之間關係如下：


排序算法.png


他們的性能比較：


性能比較.png


下面，利用Python分別將他們進行實現。

直接插入排序

  • 算法思想：

直接插入排序.gif


直接插入排序的核心思想就是：將數組中的所有元素依次跟前面已經排好的元素相比較，如果選擇的元素比已排序的元素小，則交換，直到全部元素都比較過。
因此，從上面的描述中我們可以發現，直接插入排序可以用兩個循環完成：

  1. 第一層循環：遍歷待比較的所有數組元素
  2. 第二層循環：將本輪選擇的元素(selected)與已經排好序的元素(ordered)相比較。
    如果：selected > ordered，那麼將二者交換
  • 代碼實現 
    #直接插入排序
def insert_sort(L):
  #遍歷數組中的所有元素，其中0號索引元素默認已排序，因此從1開始
  for x in range(1,len(L)):
  #將該元素與已排序好的前序數組依次比較，如果該元素小，則交換
  #range(x-1,-1,-1):從x-1倒序循環到0
      for i in range(x-1,-1,-1):
  #判斷：如果符合條件則交換
          if L[i] > L[i+1]:
              temp = L[i+1]
              L[i+1] = L[i]
              L[i] = temp

希爾排序

  • 算法思想：

希爾排序.png


希爾排序的算法思想：將待排序數組按照步長gap進行分組，然後將每組的元素利用直接插入排序的方法進行排序；每次將gap折半減小，循環上述操作；當gap=1時，利用直接插入，完成排序。
同樣的：從上面的描述中我們可以發現：希爾排序的總體實現應該由三個循環完成：

  1. 第一層循環：將gap依次折半，對序列進行分組，直到gap=1
  2. 第二、三層循環：也即直接插入排序所需要的兩次循環。具體描述見上。
  • 代碼實現： 
    #希爾排序
def insert_shell(L):
  #初始化gap值，此處利用序列長度的一般爲其賦值
  gap = (int)(len(L)/2)
  #第一層循環：依次改變gap值對列表進行分組
  while (gap >= 1):
  #下面：利用直接插入排序的思想對分組數據進行排序
  #range(gap,len(L)):從gap開始
      for x in range(gap,len(L)):
  #range(x-gap,-1,-gap):從x-gap開始與選定元素開始倒序比較，每個比較元素之間間隔gap
          for i in range(x-gap,-1,-gap):
  #如果該組當中兩個元素滿足交換條件，則進行交換
              if L[i] > L[i+gap]:
                  temp = L[i+gap]
                  L[i+gap] = L[i]
                  L[i] =temp
  #while循環條件折半
      gap = (int)(gap/2)

簡單選擇排序

  • 算法思想

簡單選擇排序.gif


簡單選擇排序的基本思想：比較+交換。

  1. 從待排序序列中，找到關鍵字最小的元素；
  2. 如果最小元素不是待排序序列的第一個元素，將其和第一個元素互換；
  3. 從餘下的 N - 1 個元素中，找出關鍵字最小的元素，重複(1)、(2)步，直到排序結束。
    因此我們可以發現，簡單選擇排序也是通過兩層循環實現。
    第一層循環：依次遍歷序列當中的每一個元素
    第二層循環：將遍歷得到的當前元素依次與餘下的元素進行比較，符合最小元素的條件，則交換。
  • 代碼實現 
    # 簡單選擇排序
def select_sort(L):
#依次遍歷序列中的每一個元素
  for x in range(0,len(L)):
#將當前位置的元素定義此輪循環當中的最小值
      minimum = L[x]
#將該元素與剩下的元素依次比較尋找最小元素
      for i in range(x+1,len(L)):
          if L[i] < minimum:
              temp = L[i];
              L[i] = minimum;
              minimum = temp
#將比較後得到的真正的最小值賦值給當前位置
      L[x] = minimum

堆排序

  • 堆的概念
    堆：本質是一種數組對象。特別重要的一點性質：任意的葉子節點小於（或大於）它所有的父節點。對此，又分爲大頂堆和小頂堆，大頂堆要求節點的元素都要大於其孩子，小頂堆要求節點元素都小於其左右孩子，兩者對左右孩子的大小關係不做任何要求。
    利用堆排序，就是基於大頂堆或者小頂堆的一種排序方法。下面，我們通過大頂堆來實現。

  • 基本思想：
    堆排序可以按照以下步驟來完成：

    1. 首先將序列構建稱爲大頂堆；
      （這樣滿足了大頂堆那條性質：位於根節點的元素一定是當前序列的最大值）

      構建大頂堆.png
    2. 取出當前大頂堆的根節點，將其與序列末尾元素進行交換；
      （此時：序列末尾的元素爲已排序的最大值；由於交換了元素，當前位於根節點的堆並不一定滿足大頂堆的性質）
    3. 對交換後的n-1個序列元素進行調整，使其滿足大頂堆的性質；

      Paste_Image.png
    4. 重複2.3步驟，直至堆中只有1個元素爲止

  • 代碼實現：

    #-------------------------堆排序--------------------------------
#**********獲取左右葉子節點**********
def LEFT(i):
  return 2*i + 1
def RIGHT(i):
  return 2*i + 2
#********** 調整大頂堆 **********
#L:待調整序列 length: 序列長度 i:需要調整的結點
def adjust_max_heap(L,length,i):
#定義一個int值保存當前序列最大值的下標
  largest = i
#執行循環操作：兩個任務：1 尋找最大值的下標；2.最大值與父節點交換
  while (1):
#獲得序列左右葉子節點的下標
      left,right = LEFT(i),RIGHT(i)
#當左葉子節點的下標小於序列長度 並且 左葉子節點的值大於父節點時，將左葉子節點的下標賦值給largest
      if (left < length) and (L[left] > L[i]):
          largest = left
          print('左葉子節點')
      else:
          largest = i
#當右葉子節點的下標小於序列長度 並且 右葉子節點的值大於父節點時，將右葉子節點的下標值賦值給largest
      if (right < length) and (L[right] > L[largest]):
          largest = right
          print('右葉子節點')
#如果largest不等於i 說明當前的父節點不是最大值，需要交換值
      if (largest != i):
          temp = L[i]
          L[i] = L[largest]
          L[largest] = temp
          i = largest
          print(largest)
          continue
      else:
          break
#********** 建立大頂堆 **********
def build_max_heap(L):
  length = len(L)
  for x in range((int)((length-1)/2),-1,-1):
      adjust_max_heap(L,length,x)
#********** 堆排序 **********
def heap_sort(L):
#先建立大頂堆，保證最大值位於根節點；並且父節點的值大於葉子結點
  build_max_heap(L)
#i：當前堆中序列的長度.初始化爲序列的長度
  i = len(L)
#執行循環：1. 每次取出堆頂元素置於序列的最後(len-1,len-2,len-3...)
#         2. 調整堆，使其繼續滿足大頂堆的性質，注意實時修改堆中序列的長度
  while (i > 0):
      temp = L[i-1]
      L[i-1] = L[0]
      L[0] = temp
#堆中序列長度減1
      i = i-1
#調整大頂堆
      adjust_max_heap(L,i,0)

冒泡排序

  • 基本思想

    冒泡排序.gif

    冒泡排序思路比較簡單：
    1. 將序列當中的左右元素，依次比較，保證右邊的元素始終大於左邊的元素；
      （ 第一輪結束後，序列最後一個元素一定是當前序列的最大值；）
    2. 對序列當中剩下的n-1個元素再次執行步驟1。
    3. 對於長度爲n的序列，一共需要執行n-1輪比較
      （利用while循環可以減少執行次數）

*代碼實現

#冒泡排序
def bubble_sort(L):
    length = len(L)
#序列長度爲length，需要執行length-1輪交換
    for x in range(1,length):
#對於每一輪交換，都將序列當中的左右元素進行比較
#每輪交換當中，由於序列最後的元素一定是最大的，因此每輪循環到序列未排序的位置即可
        for i in range(0,length-x):
            if L[i] > L[i+1]:
                temp = L[i]
                L[i] = L[i+1]
                L[i+1] = temp

快速排序

  • 算法思想：

    快速排序.gif

    快速排序的基本思想：挖坑填數+分治法
    1. 從序列當中選擇一個基準數(pivot)
      在這裏我們選擇序列當中第一個數最爲基準數
    2. 將序列當中的所有數依次遍歷，比基準數大的位於其右側，比基準數小的位於其左側
    3. 重複步驟1.2，直到所有子集當中只有一個元素爲止。
      用僞代碼描述如下：
      1．i =L; j = R; 將基準數挖出形成第一個坑a[i]。
      2．j--由後向前找比它小的數，找到後挖出此數填前一個坑a[i]中。
      3．i++由前向後找比它大的數，找到後也挖出此數填到前一個坑a[j]中。
      4．再重複執行2，3二步，直到i==j，將基準數填入a[i]中
  • 代碼實現： 
    #快速排序
#L：待排序的序列；start排序的開始index,end序列末尾的index
#對於長度爲length的序列：start = 0;end = length-1
def quick_sort(L,start,end):
  if start < end:
      i , j , pivot = start , end , L[start]
      while i < j:
#從右開始向左尋找第一個小於pivot的值
          while (i < j) and (L[j] >= pivot):
              j = j-1
#將小於pivot的值移到左邊
          if (i < j):
              L[i] = L[j]
              i = i+1 
#從左開始向右尋找第一個大於pivot的值
          while (i < j) and (L[i] < pivot):
              i = i+1
#將大於pivot的值移到右邊
          if (i < j):
              L[j] = L[i]
              j = j-1
#循環結束後，說明 i=j，此時左邊的值全都小於pivot,右邊的值全都大於pivot
#pivot的位置移動正確，那麼此時只需對左右兩側的序列調用此函數進一步排序即可
#遞歸調用函數：依次對左側序列：從0 ~ i-1//右側序列：從i+1 ~ end
      L[i] = pivot
#左側序列繼續排序
      quick_sort(L,start,i-1)
#右側序列繼續排序
      quick_sort(L,i+1,end)

歸併排序

  • 算法思想：


    歸併排序.gif
    1. 歸併排序是建立在歸併操作上的一種有效的排序算法，該算法是採用分治法的一個典型的應用。它的基本操作是：將已有的子序列合併，達到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。

    2. 歸併排序其實要做兩件事：

      • 分解----將序列每次折半拆分
      • 合併----將劃分後的序列段兩兩排序合併
        因此，歸併排序實際上就是兩個操作，拆分+合併

    3. 如何合併？
      L[first...mid]爲第一段，L[mid+1...last]爲第二段，並且兩端已經有序，現在我們要將兩端合成達到L[first...last]並且也有序。

      • 首先依次從第一段與第二段中取出元素比較，將較小的元素賦值給temp[]
      • 重複執行上一步，當某一段賦值結束，則將另一段剩下的元素賦值給temp[]
      • 此時將temp[]中的元素複製給L[]，則得到的L[first...last]有序

    4. 如何分解？
      在這裏，我們採用遞歸的方法，首先將待排序列分成A,B兩組；然後重複對A、B序列
      分組；直到分組後組內只有一個元素，此時我們認爲組內所有元素有序，則分組結束。

  • 代碼實現

    # 歸併排序
#這是合併的函數
# 將序列L[first...mid]與序列L[mid+1...last]進行合併
def mergearray(L,first,mid,last,temp):
#對i,j,k分別進行賦值
  i,j,k = first,mid+1,0
#當左右兩邊都有數時進行比較，取較小的數
  while (i <= mid) and (j <= last):
      if L[i] <= L[j]:
          temp[k] = L[i]
          i = i+1
          k = k+1
      else:
          temp[k] = L[j]
          j = j+1
          k = k+1
#如果左邊序列還有數
  while (i <= mid):
      temp[k] = L[i]
      i = i+1
      k = k+1
#如果右邊序列還有數
  while (j <= last):
      temp[k] = L[j]
      j = j+1
      k = k+1
#將temp當中該段有序元素賦值給L待排序列使之部分有序
  for x in range(0,k):
      L[first+x] = temp[x]
# 這是分組的函數
def merge_sort(L,first,last,temp):
  if first < last:
      mid = (int)((first + last) / 2)
#使左邊序列有序
      merge_sort(L,first,mid,temp)
#使右邊序列有序
      merge_sort(L,mid+1,last,temp)
#將兩個有序序列合併
      mergearray(L,first,mid,last,temp)
# 歸併排序的函數
def merge_sort_array(L):
#聲明一個長度爲len(L)的空列表
  temp = len(L)*[None]
#調用歸併排序
  merge_sort(L,0,len(L)-1,temp)

基數排序

  • 算法思想

    基數排序.gif
    1. 基數排序：通過序列中各個元素的值，對排序的N個元素進行若干趟的“分配”與“收集”來實現排序。
      分配：我們將L[i]中的元素取出，首先確定其個位上的數字，根據該數字分配到與之序號相同的桶中
      收集：當序列中所有的元素都分配到對應的桶中，再按照順序依次將桶中的元素收集形成新的一個待排序列L[ ]
      對新形成的序列L[]重複執行分配和收集元素中的十位、百位...直到分配完該序列中的最高位，則排序結束
    2. 根據上述“基數排序”的展示，我們可以清楚的看到整個實現的過程
  • 代碼實現 
    #************************基數排序****************************
#確定排序的次數
#排序的順序跟序列中最大數的位數相關
def radix_sort_nums(L):
  maxNum = L[0]
#尋找序列中的最大數
  for x in L:
      if maxNum < x:
          maxNum = x
#確定序列中的最大元素的位數
  times = 0
  while (maxNum > 0):
      maxNum = (int)(maxNum/10)
      times = times+1
  return times
#找到num從低到高第pos位的數據
def get_num_pos(num,pos):
  return ((int)(num/(10**(pos-1))))%10
#基數排序
def radix_sort(L):
  count = 10*[None]        #存放各個桶的數據統計個數
  bucket = len(L)*[None]  #暫時存放排序結果
#從低位到高位依次執行循環
  for pos in range(1,radix_sort_nums(L)+1):
      #置空各個桶的數據統計
      for x in range(0,10):
          count[x] = 0
      #統計當前該位(個位，十位，百位....)的元素數目
      for x in range(0,len(L)):
          #統計各個桶將要裝進去的元素個數
          j = get_num_pos(int(L[x]),pos)
          count[j] = count[j]+1
      #count[i]表示第i個桶的右邊界索引
      for x in range(1,10):
          count[x] = count[x] + count[x-1]
      #將數據依次裝入桶中
      for x in range(len(L)-1,-1,-1):
          #求出元素第K位的數字
          j = get_num_pos(L[x],pos)
          #放入對應的桶中，count[j]-1是第j個桶的右邊界索引
          bucket[count[j]-1] = L[x]
          #對應桶的裝入數據索引-1
          count[j] = count[j]-1
      # 將已分配好的桶中數據再倒出來，此時已是對應當前位數有序的表
      for x in range(0,len(L)):
          L[x] = bucket[x]

後記

寫完之後運行了一下時間比較：

  • 1w個數據時： 
    直接插入排序:11.615608
希爾排序:13.012008
簡單選擇排序:3.645136000000001
堆排序:0.09587900000000005
冒泡排序:6.687218999999999
#****************************************************
快速排序:9.999999974752427e-07 
#快速排序有誤：實際上並未執行
#RecursionError: maximum recursion depth exceeded in comparison
#****************************************************
歸併排序:0.05638299999999674
基數排序:0.08150400000000246
  • 10w個數據時： 
    直接插入排序:1233.581131
希爾排序:1409.8012320000003
簡單選擇排序:466.66974500000015
堆排序:1.2036720000000969
冒泡排序:751.274449
#****************************************************
快速排序:1.0000003385357559e-06
#快速排序有誤：實際上並未執行
#RecursionError: maximum recursion depth exceeded in comparison
#****************************************************
歸併排序:0.8262230000000272
基數排序:1.1162899999999354
    從運行結果上來看，堆排序、歸併排序、基數排序真的快。
    對於快速排序迭代深度超過的問題，可以將考慮將快排通過非遞歸的方式進行實現。

參考資料

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

利用java小工具-----統計項目代碼量

package com.util; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import jav

冰之旅 2020-07-04 01:05:56

對jdbc進行封裝

對jdbc的封裝主要是對實體對象進行封裝，封裝後只需傳入實體對象或實體對象類等即可對其進行簡單操作，封裝必考慮效率特別是在數據庫連接，因 此需考慮使用數據據連接池技術（自己開發或使用第三方數據庫連接池，本人建議考慮使用第三方數據庫連接池

冰之旅 2020-07-04 01:05:56

java中使用報404錯誤

首先得確認的是，控制層框架是否採用的是struts2 1、採用Struts2的話必須在web.xml中配置<filter-mapping> <f

冰之旅 2020-07-04 01:05:46

java性能優化開發之--適當的方法體長度

JVM一開始是以解釋方式執行字節碼的，當一個方法片段執行的一定次數時，就會 被動態優化編譯爲機器碼執行，速度大大加快，這就是所有的JIT編譯 在JVM默認的情況下，8k字節以上的方法無論執行多少次，始終是不會被編譯成機器碼執行 可以通過“

lidaweihgy 2020-06-28 14:47:17

學習java基礎：java開發常用技術

基礎部分 1. 線程和進程的區別 線程三個基本狀態：就緒、執行、阻塞 線程五個基本操作：創建、就緒、運行、阻塞、終止 進程四種形式：主從式、會話式、

molihuaya 2020-06-27 01:30:34

svn文件圖標不能正常顯示，在Lable Decorations 勾選其中的 SVN 項後一會兒又不顯示了

在網上看了很多解決方法，都是說下面這樣操作，但我照着操作之後，點擊apply後，是可以顯示了， 但過了1分鐘後，又不顯示了，我再點開Lable Decorations 看裏面的svn剛剛還勾選的，現在就莫名奇妙的又沒選中了。 最後直

星马殇 2020-06-25 12:23:25

form提交 jquery ajax

<script language="javascript" type="text/javascript" src="/js/jquery/jquery-1.4.2.min.js"></script> <script language="j

星马殇 2020-06-25 12:23:24

java兩個站點之間url傳中文亂碼的問題

正確的代碼是： 請求站點傳的url如下： HttpRequest request = new HttpRequest("http://ibicn:8080/addBack.jsp?&titles="+URLEncoder.encode(t

星马殇 2020-06-25 12:23:24

dom4j讀寫xml文件方法和具體實現代碼（提供jar包下載）

dom4j是一個Java的XML API，類似於jdom，用來讀寫XML文件的。dom4j是一個十分優秀的JavaXML API，具有性能優異、功能強大和極其易使用的特點，同時它也是一個開放源代碼的軟件，可以在Source

李永昌 2020-06-23 13:34:40

jQuery操作父窗口

1) 判斷元素是否存在$("#yourid").length>0 表示id爲yourid的元素存在,否則表示不存在; 2) 獲取父窗口的元素$("#yourid", opener.document)等同於普通寫法opener.docum

whaosy 2020-06-22 04:14:25

【java】【多線程】等待開啓的多個線程都執行完成，再做事情，怎麼實現 《轉》

本文轉自: https://www.cnblogs.com/sxdcgaq8080/p/9456006.html   怎麼能有效保證高併發下的庫存和銷量的一致性呢？【具體實現方法：https://www.cnblogs.com/sxdcg

whaosy 2020-06-22 04:14:14

ComparatorChain對List對象的屬性排序

一、按升序 / 降序對List中的對象進行排序 需要使用到對象 org.apache.commons.beanutils.BeanComparator; org.apache.commons.collections.comparators

csdn_liuliu 2020-06-20 12:52:04

Activiti應用實踐(一)-流程開發環境搭建及開發示例

一、背景 activiti是常用的作業流管理工具，由於最近的項目中涉及，提前研究一下。先從官方網站下載activiti流程編輯工具(https://www.activiti.org/get-started)。一般來講商業項目會選擇

Elon.Yang 2020-06-19 02:29:12

關於Struts2的action操作的一些常用方式

1.怎麼樣動態調用action的方法： Struts.xml中如下配置 <action name="practicedbdelete" class="com.dream.FileClasses.PracticeAction"

menglongma 2020-06-16 10:42:33

try....catch...finally 妙用

try....catch...finally 妙用      如果程序需要有自恢復的能力，那麼就要把可能會導致程序進程掛掉的，代碼放在 try{ do something here }catch(){   }finally{ T

blueman2012 2020-06-15 16:27:42