數據結構筆記：快速排序

原文地址

分類目錄——數據結構筆記

• 建議必須要掌握的，用的比較多。

• 理解1

  每次取出第1個元素，剩餘元素算作一個序列，使用兩個指針分置兩端，姑且吧左端稱之爲小指針，把右端稱之爲大指針，作用就是爲了給第1個元素找的合適的位置。比較小指針指向值與第1個元素，如果比第1元素小說明符合要求，繼續後移去判斷下一個，如果不滿足要求，即小指針的值比第1元素大了，停住小指針，去最右端看大指針，如果大指針指的值比第1元素值大，符合要求，大指針前移再判斷，如果不滿足要求，也就是大指針指的值比第1元素值小了，停住大指針。這時候兩個指針都停住了，那麼只要置換兩個指針當前的指向值，兩個就都滿足要求了，然後繼續從小指針開始比較。待到小指針與大指針重合了，那麼這時候小指針（也可以說是大指針，因爲重合了）

  第1個元素找到位置後，把序列按它分成前後兩部分，分別對着兩部分在進行上述操作

  直到最後每部分只有一個元素

• 理解方式2

  代碼實現起來更容易

  取第1個元素定義爲mid_value，首尾定義兩個指針，左首姑且叫它小指針（這是它指向第一個位置——mid_value），右首姑且叫它大指針。小指針在mid_value上，去動右側大指針，如果比mid_value大，滿足條件，繼續向前查詢，如果查詢到小於min_value，與小指針的值（mid_value）交換，此時大指針指向mid_value，去動小指針，滿足條件（比min_value小），右移繼續去查詢，如果不滿足（比mid_value大），與大指針對應值（mid_value）交換，知道大小指針重合，mid_value也就在了它應該所在的中間位置。

• 實現

  通過理解2的方式實現

  def quicksort(alist, begin, end):
      if begin>=end:
          return
      mid_value = alist[begin]
      low = begin
      high = end
  
      # 對確定本輪迭代中mid_value在alist[begin： end]中的位置
      while low < high:
          # 左移
          while low < high and alist[high] >= mid_value:
              # 在思想上，將mid_value就當做一個分界線，如果有相同的mid_value，儘量把這些相同值放在同一側，這裏選擇了放在左側
              high -= 1
          alist[low] = alist[high]
          # low += 1  # 寧可多加一步比較，寫在這裏會讓小指針與大指針錯過
          # 右移
          while low < high and alist[low] < mid_value:
              low += 1
          alist[high] = alist[low]
          # high -= 1
      # 從循環退出時，low=high
      alist[low] = mid_value
  
      # 對左右兩部分再遞歸進行快速排序
      # quicksort(alist[:low])    # 這麼傳參是不對滴，切片會生成一個新的list，這樣只是對新的list做排序，不會返回到原list中
      # quicksort(alist[low+1:])  # 所以對函數進行了整體改動，加入了傳入了其實終止值
  
      # 對mid_value(確定位置後)左邊進行quicksort
      quicksort(alist, begin, low-1)
      # 對mid_value(確定位置後)右邊進行quicksort
      quicksort(alist, low+1, end)
  

• 測試

  if __name__ == '__main__':
      ll = [3,6,2,4,7,5,8,1,0,9]
      print(ll)
      quicksort(ll, 0, len(ll)-1)
      print(ll)
  

• 時間複雜度

  • 最優時間複雜度：O(nlogn)
  • 最壞時間複雜度：O(n^2)
  • 穩定性：不穩定

  從一開始快速排序平均需要花費O(n log n)時間的描述並不明顯。但是不難觀察到的是分區運算，數組的元素都會在每次循環中走訪過一次，使用O(n)的時間。在使用理解2的版本中，這項運算也是O(n)。

  在最好的情況，每次我們運行一次分區，我們會把一個數列分爲兩個幾近相等的片段。這個意思就是每次遞歸調用處理一半大小的數列。因此，在到達大小爲一的數列前，我們只要作log n次嵌套的調用。這個意思就是調用樹的深度是O(log n)。但是在同一層次結構的兩個程序調用中，不會處理到原來數列的相同部分；因此，程序調用的每一層次結構總共全部僅需要O(n)的時間（每個調用有某些共同的額外耗費，但是因爲在每一層次結構僅僅只有O(n)個調用，這些被歸納在O(n)係數中）。結果是這個算法僅需使用O(n log n)時間。