幾種常見的排序方法

常見算法效率比較：

 

一. 冒泡排序

冒泡排序是是一種簡單的排序算法。它重復地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把它們交換過來。遍歷數列的工作是重復的進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端

1.冒泡排序算法的運作如下：

（1）比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個

（2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素還是最大的數

（3）針對所有的元素重復以上的步驟，除了最后一個

2.冒泡排序的分析：

交換過程圖示（第一次）

那么我們需要進行n-1次冒泡過程，每次對應的比較次數如下圖所示

代碼如下：

def bubble_sort(alist):
      # j為每次遍歷需要比較的次數，是逐漸減小的
      for j in range(len(alist)-1,0,-1):
           for i in range(j):
                if alist[i] > alist[i+1]:
                    alist[i], alist[i+1] = alist[i+1],alist[i] 
li = [1,3, 4, 5, 2, 11, 6, 9, 15]
bubble_sort(li)
print(li)

3. 時間復雜度

算法的時間復雜度是指算法執行的過程中所需要的基本運算次數

（1）最優時間復雜度：O（n）（表示遍歷一次發現沒有任何可以交換的元素，排序結束）

（2）最壞時間復雜度：O(n²) 

（3）穩定性：穩定

         假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經過排序，這些記錄的相對次序保持不變，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，則稱這種排序算法是穩定的；否則稱為不穩定的     

        常見算法的穩定性（要記住）

                堆排序、 快速排序、 希爾排序、 直接選擇排序不是穩定的排序算法，而 基數排序、 冒泡排序、 直接插入排序、 折半插入排序、 歸並排序是穩定的排序算法。

 

 

二. 選擇排序

    選擇排序是一種簡單直觀的排序算法。他的工作原理如下：

    首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置（末尾位置），然后，再從剩余未排序元素中繼續尋找最小（大）元素 ，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢

    選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，他們當中至少有一個將被移到最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動      元素的排序方法中，選擇排序屬於非常好的一種

 

  1. 選擇排序分析

 

排序過程：

 紅色表示當前最小值，黃色表示已排序列，藍色表示當前位置

 

 具體代碼：

def selection_sort(alist):
    for i in range(len(alist)-1):
　　　　 # 定義最小數對應的下標，一開始為0
        min_index = i
        for j in range(i+1,n):
            if alist[j] < alist[min_index]:
                # 交換下標，數據不進行交換
                min_index = j
        if min_index != i:
            alist[min_index], alist[i] = alist[i], alist[min_index]

2. 時間復雜度

（1）最優時間復雜度：O(n²)

（2）最壞時間復雜度：O(n²)

（3）穩定性：不穩定（升序的時候不穩定，相等兩個數的相對位置一定會發生變化）

  三. 插入排序

 

 插入排序是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從后向前掃描，找到相應位置並插入。插入排序在從后向前掃描的過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間

 

 1.插入排序分析：

代碼實現：

def insert_sort(alist):
    # 從第二個元素開始向前插入
    for i in range(1, len(alist)):
        for j in range(i, 0, -1):
            if alist[j] < alist[j-1]:
                alist[j], alist[j-1] = alist[j-1], alist[j]

 

 2. 時間復雜度

（1）最優時間復雜度：O(n)（升序排列，序列已經處於升序狀態）

（2）最壞時間復雜度：O(n ²)

（3）穩定性：穩定

 

四. 快速排序

 快速排序，又稱划分交換排序。通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都要小，然后再按此方法對兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列

步驟為：

（1） 從數列中挑選一個元素，稱為“基准”

（2） 重新排序數列，所有元素比基准值小的擺放在基准前面，所有元素比基准值大的擺在基准的后面（相同的數可以放到任意一邊，但一般都統一放到一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區操作

（3）遞歸的把小於基准值元素的子數列和大於基准值元素的子數列排序

遞歸的最底部情形，是數列的大小基准值元素的子數列和大於基准值元素的子數列排序

 

1.快速排序的分析：

代碼如下：

def quick_sort(alist, start, end):
    """快速排序"""
    # 遞歸的退出條件
    if start >= end:
        return
    # 設定起始元素為要尋找位置的基准元素
    mid = alist[start]
    # low為序列左邊的由左向右移動的游標
    low = start
    # high為序列右邊的由右向左移動的游標
    high = end

    while low < high:
        # 如果low與high未重合，high指向的元素不比基准元素小，則high向左移動
        while low < high and alist[high] >= mid:
            high -= 1
        # 將high指向的元素放到low的位置上
        alist[low] = alist[high]

        # 如果low與high未重合，low指向的元素比基准元素小，則low向右移動
        while low < high and alist[low] < mid:
            low += 1
        # 將low指向的元素放到high的位置上
        alist[high] = alist[low]

    # 退出循環后，low與high重合，此時所指位置為基准元素的正確位置
    # 將基准元素放到該位置
    alist[low] = mid

    # 對基准元素左邊的子序列進行快速排序
    quick_sort(alist, start, low-1)

    # 對基准元素右邊的子序列進行快速排序
    quick_sort(alist, low+1, end)

2. 時間復雜度

（1）最優時間復雜度：O(nlogn)

（2）最壞時間復雜度：O(n²)

（3）穩定性：不穩定

 

五 希爾排序過程

希爾排序是插入排序的一種，也稱縮小增量排序，是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨着增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

1.代碼實現：

def shell_sort(alist):
    n = len(alist)
    # 初始步長
    gap = n / 2
    while gap > 0:
        # 按步長進行插入排序
        for i in range(gap, n):
            j = i
            # 插入排序
            while j>=gap and alist[j-gap] > alist[j]:
                alist[j-gap], alist[j] = alist[j], alist[j-gap]
                j -= gap
        # 得到新的步長
        gap = gap / 2

2. 時間復雜度

（1）最優時間復雜度：根據步長序列的不同而不同

（2）最壞時間復雜度：O（n²）

（3）穩定性：不穩定

 

六. 歸並排序

歸並排序是采用分治法（把復雜問題分解為相對簡單的子問題，分別求解，最后通過組合起子問題的解的方式得到原問題的解）的一個非常典型的應用。歸並排序的思想就是先遞歸分解數組，再合並數組

將數組分解最小之后，然后合並兩個有序數組，基本思路是比較兩個數組的最前面的數，水小九先取誰，取了后相應的指針就往后移一位。然后比較，直至一個數組為空，最后把另一個數組的剩余部分復制過來即可

1. 歸並排序分析

代碼實現：

def merge_sort(alist):
    if len(alist) <= 1:
        return alist
    # 二分分解
    num = len(alist)/2
    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])
    # 合並
    return merge(left,right)

def merge(left, right):
    '''合並操作，將兩個有序數組left[]和right[]合並成一個大的有序數組'''
    #left與right的下標指針
    l, r = 0, 0
    result = []
    while l<len(left) and r<len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result

2.時間復雜度

（1）最優時間復雜度：O(nlogn)

（2）最壞時間復雜度：O(nlogn)

（3）穩定性：穩定