寫在前面

本文參考十大經典排序算法(動圖演示)，這篇文章有動圖顯示，介紹的很詳細。本文是部分內容有借鑒此博客，用python實現，有一些改進。

各種算法的時間、空間復雜度

1.冒泡排序

1.比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；

2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對，這樣在最后的元素應該會是最大的數；

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

4.重復步驟1~3，直到排序完成。

1 defbubbleSort(arr):2 for i inrange(len(arr)):3 for j in range(len(arr)-i-1):4 if arr[j]>arr[j+1]:5 temp = arr[j+1]6 arr[j+1] =arr[j]7 arr[j] =temp8 return arr

冒泡排序就是比較，交換位置，一般認為時間復雜度都是O(n2)，查了一下也可以優化代碼，設置一個flag來減少比較次數，使最快時間復雜度可以到O(n)。

1 defbubbleSort1(arr):2 print(arr)3 k = len(arr)-1

4 #設置pos位置標記，j后面沒有進行排序，pos=j，下一趟掃描就只循環到pos

5 pos =06 for i in range(len(arr)-1):7 #設置flag標記,如果發生了交換flag=1

8 flag =09 for j inrange(k):10 if arr[j]>arr[j+1]:11 temp = arr[j+1]12 arr[j+1] =arr[j]13 arr[j] =temp14 flag = 1

15 pos =j16 k =pos17 #沒有發生交換就推出循環

18 if flag ==0:19 break

20 return arr

2.選擇排序

選擇排序就是選擇最小的元素和第一個交換。將n個元素的數組第一個元素默認為最小值min，從后面的元素中選擇最小值與min比較大小，交換。然后將第二個元素設置為min，繼續比較交換。

n-1次比較后排序完成。

1 defselectionSort(arr):2 for i inrange(len(arr)):3 min =i4 for j in range(i+1,len(arr)):5 if arr[j]

8 temp =arr[i]9 arr[i] =arr[min]10 arr[min] =temp11 return arr

3.插入排序

從未排序的元素中依次向已排序數組插入。

1.從第一個元素開始，該元素可以認為已經被排序；

2.取出下一個元素，在已經排序的元素序列中從后向前掃描；

3.如果該元素(已排序)大于新元素，將該元素移到下一位置；

4.重復步驟3，直到找到已排序的元素小于或者等于新元素的位置；

5.將新元素插入到該位置后；

6.重復步驟2~5

1 definsertionSort(arr):2 for i in range(1,len(arr)):3 preIndex = i-1

4 current =arr[i]5 #從已排序的數組最后一個元素開始比較，依次向前，找到位置后插入

6 while preIndex>=0 and arr[preIndex]>current:7 arr[preIndex+1] =arr[preIndex]8 preIndex -= 1

9 arr[preIndex+1] =current10 return arr

4.希爾排序

希爾排序是插入排序的改進版，插入排序是從已排序的最后一位開始比較，相應的比較時間會增加。希爾排序增加一個間隔，有相同間隔的數會先比較，交換元素。設置動態間隔最后會變成插入排序，但是比較次數會大大減少。

1 defshellSort(arr):2 gap = len(arr) // 2

3 while gap >= 1:4 for j inrange(gap,len(arr)):5 i =j6 while i-gap >=0:7 if arr[i]

12 gap //= 2

13 print(arr)14 return arr

5.歸并排序

歸并排序是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法(Divide and Conquer)的一個非常典型的應用。將已有序的子序列合并，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。

若將兩個有序表合并成一個有序表，稱為2-路歸并。

1 defmergeSort(arr):2 if len(arr)<2:3 returnarr4 mid = len(arr)//2

5 left =arr[0:mid]6 right =arr[mid:]7 print(left,'---',right)8 #遞歸調用本身，進行排序

9 returnmerge(mergeSort(left),mergeSort(right))10

11 defmerge(left,right):12 result =[]13 while len(left)>0 and len(right)>0:14 print(left,'--',right)15 if left[0] <=right[0]:16 result.append(left.pop(0))17 else:18 result.append(right.pop(0))19 if len(left)>0:20 result.extend(left)21 iflen(right):22 result.extend(right)23 print(result)24 return result

6.快速排序

快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序

#設置i，j作為指針，指向要排序數組的頭尾，找一個基準，一般是數組開頭。

#在i

#將前后數組繼續遞歸調用排序，直到排序完成。

1 defquickSort(arr,start,end):2 if start<3>

4 i, j =start, end5 key =arr[i]6 while i<7>

8 while i=key:9 j -= 1

10 arr[i] =arr[j]11 while i

13 arr[j] =arr[i]14 #將中間的數替換為key

15 arr[i] =key16 #遞歸調用

17 quickSort(arr,start,i-1)18 quickSort(arr,j+1,end)19 return arr

7.堆排序

通常堆是通過一維數組來實現的。在陣列起始位置為0的情況中

(1)父節點i的左子節點在位置(2*i+1);

(2)父節點i的右子節點在位置(2*i+2);

(3)子節點i的父節點在位置(i-1)//2;

1 #調整堆

2 defMAX_Heapify(heap,HeapSize,root):3 left = 2*root + 1

4 right = left + 1

5 larger =root6 if left < HeapSize and heap[larger]

14

15 #構建堆

16 defBuild_MAX_Heap(heap):17 HeapSize =len(heap)18 for i in range((HeapSize-2)//2,-1,-1):19 MAX_Heapify(heap,HeapSize,i)20

21 #取堆頂元素

22 defHeapSort(heap):23 Build_MAX_Heap(heap)24 for i in range(len(heap)-1,-1,-1):25 heap[0],heap[i] =heap[i],heap[0]26 MAX_Heapify(heap,i,0)27 print(heap)28 returnheap29

30

31 arr = [2,3,5,4,1,8,6,7,9]32 HeapSort(arr)33 print(arr)

8.計數排序

計數排序不是基于比較的排序算法，其核心在于將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中。 作為一種線性時間復雜度的排序，計數排序要求輸入的數據必須是有確定范圍的整數。

1 defcountingSort(arr,max):2

3 result = [0 for i inrange(len(arr))]4 mid = [0 for i in range(max+1)]5 for i inarr:6 mid[i] = mid[i]+1

7

8 #累加，A0,A1,A2....Ai：相應位置的值在結果中哪一位,i的值在Ai位

9 for i in range(1,len(mid)):10 mid[i] = mid[i]+mid[i-1]11

12 for i inarr:13 result[mid[i]-1] =i14 mid[i] -= 1

15 return result

9.桶排序

桶排序是計數排序的升級版，分為兩種：范圍為1~max的桶排序和區間均勻分布的桶排序

范圍為1~max的桶排序將計數累加，得到對應數在排序結果中的位置，再進行遍歷輸出。

1 #范圍為1~max的桶排序

2 defbucketSort1(arr,max):3 mid = [0 for i in range(max+1)]4 for i inarr:5 mid[i] = mid[i]+1

6 print(mid)7 result =[]8 for i inrange(len(mid)):9 while mid[i] >0:10 result.append(i)11 mid[i] -= 1

12 print(arr)13 print(result)

1 #區間[0,1)均勻分布的桶排序

2 defbucketSort2(arr):3 result =[]4 n =len(arr)5 #嵌套數組，n個元素

6 s = [[] for i inrange(n)]7 #將每個元素放進對應的桶中

8 for i inarr:9 s[int(i*n)].append(i)10

11 #兩種排序相結合

12 for i ins:13 insert(i)14 result.extend(i)15 print(result)16 returnresult17 #輔助函數，插入排序

18 definsert(arr):19 for i in range(1,len(arr)):20 pre = i-1

21 key =arr[i]22 while pre >= 0 and arr[pre] >=key:23 arr[pre+1] =arr[pre]24 pre -= 1

25 arr[pre+1] = key

10.基數排序

基數排序一般用于長度相同的元素組成的數組。首先按照最低有效數字進行排序，然后由低位向高位進行。

長度給出,基數排序可以看做是進行多趟桶排序。每個有效數字都在0-9之間，很適合桶排序，建10個桶很方便.

1 defradixSort(arr,length):2 for i inrange(length):3 s = [[] for j in range(10)]4 for k inarr:5 #求相應位的值

6 s[int(k/(10**i)%10)].append(k)7 #將每一個桶里的元素取出,可以放進原數組

8 arr =[]9 for a ins:10 arr.extend(a)11 print(arr)12 return arr

整理的比較多可能會有出錯的地方，歡迎改正。

7>3> 與50位技術專家面對面20年技術見證，附贈技術全景圖

總結

以上是生活随笔為你收集整理的python经典排序_python实现十大经典排序算法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。