【數據結構與算法】003—排序算法（Python）

寫在前面

常見排序算法能夠分爲兩大類:

• 非線性時間比較類排序：經過比較來決定元素間的相對次序，因爲其時間複雜度不能突破O(nlogn)，所以稱爲非線性時間比較類排序。

• 線性時間非比較類排序：不經過比較來決定元素間的相對次序，它能夠突破基於比較排序的時間下界，以線性時間運行，所以稱爲線性時間非比較類排序。

排序複雜度

類別	名稱	時間複雜度	穩定性
插入排序	插入排序（insertion sort）	O(n2)	穩定
插入排序	希爾排序 （shell sort）	O(nlogn)	不穩定
選擇排序	選擇排序（selection sort）	O(n2)	不穩定
選擇排序	堆排序 （heapsort）	O(nlogn)	不穩定
交換排序	冒泡排序（bubble sort）	O(n2)	穩定
交換排序	快速排序（quicksort）	O(nlogn)	不穩定
歸併排序	歸併排序 （merge sort）	O(nlogn)	穩定
基數排序	基數排序（radix sort）	O(n+k)	穩定

---

冒泡排序

它重複地走訪過要排序的元素列，依次比較兩個相鄰的元素，若是他們的順序（如從大到小、首字母從A到Z）錯誤就把他們交換過來。

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

nums = [2, 1, 34, 4, 6, 3, 6]
result = bubbleSort(nums)
print(result)

[1, 2, 3, 4, 6, 6, 34]

選擇排序

每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，

而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到所有待排序的數據元素排完。

def selectSort(nums):
    for i in range(len(nums) - 1):
        index = i
        for j in range(i + 1, len(nums)):
            if nums[j] < nums[index]:
                index = j
        if index != i:
            nums[i], nums[index] = nums[index], nums[i]
    return nums

nums = [2, 1, 34, 4, 6, 3, 6]
result = selectSort(nums)
print(result)

[1, 2, 3, 4, 6, 6, 34]

插入排序

每步將一個待排序的記錄，按其關鍵碼值的大小插入前面已經排序的文件中適當位置上，直到所有插入完爲止。

時間複雜度：O（n^2）.

def insertSort1(nums):
    for i in range(1, len(nums)):
        index = nums[i]
        j = i - 1
        while j >= 0 and nums[j] > index:
            nums[j+1] = nums[j]
            j-=1
        nums[j+1] = index
    return nums

nums = [2, 4, 1 ,0, 4, 3, 2, 5]
result = insertSort1(nums)
print(result)

[0, 1, 2, 2, 3, 4, 4, 5]

下面方法會遍歷到nums[-1]，若是nums[-1] > index則進行交換，可是循環結束，nums[0]仍會賦值爲index

def insertSort(nums):
    for i in range(1, len(nums)):
        index = nums[i]
        for j in range(i, -1, -1):
            if index < nums[j - 1]:     #該方法會遍歷到nums[-1]，若是nums[-1] > index則進行交換，可是循環結束，nums[0]仍會賦值爲index
                nums[j]= nums[j - 1]
            else:
                break
        nums[j] = index
    return nums

nums = [2, 4, 1 ,0, 4, 3, 2, 5]
result = insertSort(nums)
print(result)

[0, 1, 2, 2, 3, 4, 4, 5]

快速排序

快速排序原理是首先要找到一箇中樞，把小於中樞的值放到他前面，
大於中樞的值放到他的右邊，而後再以此方法對這兩部分數據分別
進行快速排序。先看一下代碼

時間複雜度：O(nlgn)

def quickSort(nums,start,end):
    #判斷low是否小於high,若是爲false,直接返回
    if start < end:
        i,j = start,end
        #設置基準數
        base = nums[i]

        while i < j:
            #若是列表後邊的數,比基準數大或相等,則前移一位直到有比基準數小的數出現
            while (i < j) and (nums[j] >= base):
                j = j - 1

            #如找到,則把第j個元素賦值給第個元素i,此時表中i,j個元素相等
            nums[i] = nums[j]

            #一樣的方式比較前半區
            while (i < j) and (nums[i] <= base):
                i = i + 1
            nums[j] = nums[i]
        #作完第一輪比較以後,列表被分紅了兩個半區,而且i=j,須要將這個數設置回base
        nums[i] = base

        #遞歸先後半區
        quickSort(nums, start, i - 1)
        quickSort(nums, j + 1, end)
    return nums


nums = [49,38,65,97,76,13,27,49]
print("Quick Sort: ")
quickSort(nums,0,len(nums)-1)
print(nums)

持續更新中..,