常用排序演算法

 目錄

一、氣泡排序

二、選擇排序

三、插入排序

四、快速排序

五、堆排序

六、歸併排序

七、基數排序

八、希爾排序

九、桶排序

十、總結

---

一、氣泡排序

1、思路：首先，列表每兩個相鄰的數比較大小，如果前邊的比後邊的大，那麼這兩個數就互換位置。就像是冒泡一樣

2、程式碼關鍵點：

• 趟數：n-1趟
• 無序區

3、圖示說明：依次類推就會得到排序結果。氣泡排序的效率還是很低的

4、程式碼示例

 1
 
 # 思路：列表中兩個相鄰的數比較大小，如果前邊的比後邊的大，那麼這兩個就互換位置
 2 def bubblr_sort(li):
 3     for i in range(1,len(li)-1):#表示趟數
 4         change = True
 5         for j in range(len(li)-i):  #表示無序區，無序區的範圍為0,len(li)-i
 6             if li[j] > li[j+1]:
 7                 li[j],li[j+1] = li[j+1],li[j]
 8                 change = True
 
 9         if not change:
10             return
11 
12 li = list(range(10))
13 import random
14 random.shuffle(li)
15 print(li)
16 bubblr_sort(li)
17 print(li)

氣泡排序

 

 

時間複雜度：O(n2)

二、選擇排序

1、思路：一趟遍歷完記錄最小的數，放到第一個位置；在一趟遍歷記錄剩餘列表中的最小的數，繼續放置

2、程式碼關鍵點：

• 無序區
• 最小數的位置

3、問題：怎麼選出最小的數？

 1 import random
 2 def select_sort(li):
 3     for i in range(len(li)-1):
 4         #i 表示躺數，也表示無序區開始的位置
 5         min_loc = i  #最小數的位置
 6         for j in range(i+1,len(li)):  #i  ,i+1，就是後一個位置的範圍
 7             # [9, 2, 1, 6, 5, 8, 3, 0, 7, 4]
 8             # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 9             if li[j] <li[min_loc]:  #兩個位置進行比較，如果後面的一個比最小的那個位置還小，說明就找到最小的了
10                 min_loc = j   #找到最小的位置
11         li[i],li[min_loc] = li[min_loc],li[i]  #吧找到的兩個值進行互換位置
12 li = list(range(10))
13 random.shuffle(li)
14 print(li)
15 select_sort(li)
16 print(li)

選擇排序

 4、時間複雜度：O(n2)

三、插入排序

1、思路：元素被分為有序區和無序區兩部分。最初有序區只有一個元素。每次從無序區中選擇一個元素，插入到有序區的位置，直到無序區變空。

2、程式碼關鍵點：

• 摸到的牌
• 手裡的牌

3、圖示說明

插入後：

4、程式碼示例

 1 import random
 2 def insert_sort(li):
 3     for i in range(1,len(li)):
 4         #i 表示無序區的第一個數
 5         tmp = li[i]  #摸到的牌
 6         j = i-1 #指向有序區最後一個位置
 7         while li[j] >tmp and j>=0:
 8             #迴圈終止條件 li[j]<=tmp  and j==-1
 9             li[j+1] = li[j]  #向後移動
10             j-=1
11         li[j+1] = tmp
12         
13 li = list(range(10))
14 random.shuffle(li)
15 print(li)
16 insert_sort(li)
17 print(li)

插入排序

四、快速排序

1、思路：1、取一個元素p(第一個元素)，是元素p歸位（去它該去的地方）；

　　　　　2、列表被p分成兩部分，左邊的都比p小，右邊的都比p大；

　　　　　3、遞迴完成排序

2、演算法關鍵點

• 歸位
• 遞迴

3、圖示說明

4、怎麼歸併呢？先把5取出來，這時候就會有一個空位，從右邊找比5小的數填充過來，現在右邊有一個空位了，從左邊找比5大的放到右邊的空位上。依次類推，

只要left和right碰在一起，這樣就找打5的位置了

如圖示：

圖一圖二

 圖三圖四

 這樣在把找到的5的位置放進去去ok了

5、程式碼示例

 1 import time
 2 def wrapper(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         ret = func(*args,**kwargs)
 6         end = time.time()
 7         print('%s running time :%s'%(func.__name__,start-end))
 8         return ret
 9     return inner
10 
11 
12 def partition(li,left,right):
13     '''歸位函式'''
14     tmp = li[left]  #先把5取出來
15     while left < right:
16         while left < right and li[right] >= tmp:  #如果降序排列修改li[right] <= tmp
17                 right -= 1 #從右邊找比5小的數，填充到5的位置
18         li[left] = li[right]
19         while left < right and li[left] <= tmp:  #如果降序排列修改li[right] >= tmp
20                 left += 1# 從左邊找比5大的數字放在右邊的空位
21         li[right] = li[left]
22     li[left] = tmp  #當跳出迴圈條件的時候說明找到了，並且把拿出來的5在放進去
23     return left
24 
25 
26 def _quick_sort(li,left,right):
27     '''快速排序的兩個關鍵點：歸位，遞迴'''
28     if left < right:  #至少有兩個元素，才能進行遞迴
29         mid = partition(li,left,right)  #找到歸位的位置
30         _quick_sort(li,left,mid-1)  #遞迴，右邊的-1
31         _quick_sort(li,mid+1,right) #遞迴，左邊的+1
32 
33 @wrapper
34 def quick_sort(li):
35     return _quick_sort(li, 0, len(li)-1)
36 
37 @wrapper
38 def sys_sort(li):
39     '''系統排序'''
40     li.sort()
41 
42 import random
43 li = list(range(100000))
44 random.shuffle(li)
45 # print(li)
46 quick_sort(li)
47 # print(li)
48 
49 sys_sort(li)  
50 
51 #結論：系統的排序要比快排的時間快的多
52 # quick_sort running time :-0.6240355968475342
53 # sys_sort running time :-0.002000093460083008

快速排序演算法

6、快速排序的時間複雜度O(nlogn)

五、堆排序

有關對的瞭解：http://www.cnblogs.com/haiyan123/p/8400537.html

1、堆排序過程：

• 1、建立堆
• 2、得到堆頂元素，為最大元素
• 3、去掉堆頂，將堆最後一個元素放在堆頂，此時可通過一次調整重新使堆有序
• 4、堆頂元素為第二大元素
• 5、重複步驟3，直到堆變空

程式碼示例

 1 import random
 2 
 3 def _sift(li, low, high):
 4     """
 5     :param li:
 6     :param low: 堆根節點的位置
 7     :param high: 堆最有一個節點的位置
 8     :return:
 9     """
10     i = low  # 父親的位置
11     j = 2 * i + 1  # 孩子的位置
12     tmp = li[low]  # 原省長
13     while j <= high:
14         if j + 1 <= high and li[j + 1] > li[j]:  # 如果右孩子存在並且右孩子更大
15             j += 1
16         if tmp < li[j]:  # 如果原省長比孩子小
17             li[i] = li[j]  # 把孩子向上移動一層
18             i = j
19             j = 2 * i + 1
20         else:
21             li[i] = tmp  # 省長放到對應的位置上(幹部)
22             break
23     else:
24         li[i] = tmp  # 省長放到對應的位置上(村民/葉子節點)
25 
26 
27 def sift(li, low, high):
28     """
29     :param li:
30     :param low: 堆根節點的位置
31     :param high: 堆最有一個節點的位置
32     :return:
33     """
34     i = low         # 父親的位置
35     j = 2 * i + 1   # 孩子的位置
36     tmp = li[low]   # 原省長
37     while j <= high:
38         if j + 1 <= high and li[j+1] > li[j]: # 如果右孩子存在並且右孩子更大
39             j += 1
40         if tmp < li[j]: # 如果原省長比孩子小
41             li[i] = li[j]  # 把孩子向上移動一層
42             i = j
43             j = 2 * i + 1
44         else:
45             break
46     li[i] = tmp
47 
48 
49 
50 def heap_sort(li):
51     n = len(li)
52     # 1. 建堆
53     for i in range(n//2-1, -1, -1):
54         sift(li, i, n-1)
55     # 2. 挨個出數
56     for j in range(n-1, -1, -1):    # j表示堆最後一個元素的位置
57         li[0], li[j] = li[j], li[0]
58         # 堆的大小少了一個元素 （j-1）
59         sift(li, 0, j-1)
60 
61 
62 li = list(range(10))
63 random.shuffle(li)
64 print(li)
65 heap_sort(li)
66 print(li)
67 
68 # li=[2,9,7,8,5,0,1,6,4,3]
69 # sift(li, 0, len(li)-1)
70 # print(li)

堆排序

六、歸併排序

假設現在的列表分兩段有序，如何將其合成為一個有序列表。這種操作稱為一次歸併

1、思路：

2、歸併關鍵字

• 分解：將列表越分越小，直至分成一個元素
• 終止條件：一個元素是有序的
• 合併：將兩個有序列表歸併，列表越來越大

3、圖實示例：https://www.cnblogs.com/chengxiao/p/6194356.html

4、程式碼示例：

 1 import random
 2 def merge(li, low, mid, high):
 3     # 一次歸併
 4     '''
 5     :param li: 列表
 6     :param low: 起始位置
 7     :param mid: 按照那個位置分
 8     :param high: 最後位置
 9     :return:
10     '''
11     i = low
12     j = mid + 1
13     ltmp = []
14     while i <= mid and j <= high:
15         if li[i] < li[j]:
16             ltmp.append(li[i])
17             i += 1
18         else:
19             ltmp.append(li[j])
20             j += 1
21     while i <= mid:
22         ltmp.append(li[i])
23         i += 1
24     while j <= high:
25         ltmp.append(li[j])
26         j += 1
27     li[low:high+1] = ltmp
28 
29 
30 def _merge_sort(li, low, high):
31     if low < high:  # 至少兩個元素
32         mid = (low + high) // 2
33         _merge_sort(li, low, mid)
34         _merge_sort(li, mid+1, high)
35         merge(li, low, mid, high)
36         print(li[low:high+1])
37 
38 
39 def merge_sort(li):
40     return _merge_sort(li, 0, len(li)-1)
41 
42 
43 li = list(range(16))
44 random.shuffle(li)
45 print(li)
46 merge_sort(li)
47 
48 print(li)

歸併排序

5、歸併排序的時間複雜度：O(nlogn)，空間複雜度是：O(n)

總結：

LOw B 三人組

• 氣泡排序，選擇排序，直接插入排序他們的時間複雜度都是O(n^2),空間複雜度是O(1)

NB 三人組

• 快速排序，歸併排序，堆排序他們的時間複雜度都是O(nlogn)
• 三種排序演算法的缺點
  • 快速排序：極端情況下排序效率低
  • 歸併排序：需要額外的記憶體開銷
  • 堆排序：在快的排序演算法中相對較慢

挨著換的穩定，不挨著換的不穩定

 

   

 目錄

一、氣泡排序

二、選擇排序

三、插入排序

四、快速排序

五、堆排序

六、歸併排序

七、基數排序

八、希爾排序

九、桶排序

十、總結

---

一、氣泡排序

1、思路：首先，列表每兩個相鄰的數比較大小，如果前邊的比後邊的大，那麼這兩個數就互換位置。就像是冒泡一樣

2、程式碼關鍵點：

• 趟數：n-1趟
• 無序區

3、圖示說明：依次類推就會得到排序結果。氣泡排序的效率還是很低的

4、程式碼示例

 1 # 思路：列表中兩個相鄰的數比較大小，如果前邊的比後邊的大，那麼這兩個就互換位置
 2 def bubblr_sort(li):
 3     for i in range(1,len(li)-1):#表示趟數
 4         change = True
 5         for j in range(len(li)-i):  #表示無序區，無序區的範圍為0,len(li)-i
 6             if li[j] > li[j+1]:
 7                 li[j],li[j+1] = li[j+1],li[j]
 8                 change = True
 9         if not change:
10             return
11 
12 li = list(range(10))
13 import random
14 random.shuffle(li)
15 print(li)
16 bubblr_sort(li)
17 print(li)

氣泡排序

 

 

時間複雜度：O(n2)

二、選擇排序

1、思路：一趟遍歷完記錄最小的數，放到第一個位置；在一趟遍歷記錄剩餘列表中的最小的數，繼續放置

2、程式碼關鍵點：

• 無序區
• 最小數的位置

3、問題：怎麼選出最小的數？

 1 import random
 2 def select_sort(li):
 3     for i in range(len(li)-1):
 4         #i 表示躺數，也表示無序區開始的位置
 5         min_loc = i  #最小數的位置
 6         for j in range(i+1,len(li)):  #i  ,i+1，就是後一個位置的範圍
 7             # [9, 2, 1, 6, 5, 8, 3, 0, 7, 4]
 8             # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 9             if li[j] <li[min_loc]:  #兩個位置進行比較，如果後面的一個比最小的那個位置還小，說明就找到最小的了
10                 min_loc = j   #找到最小的位置
11         li[i],li[min_loc] = li[min_loc],li[i]  #吧找到的兩個值進行互換位置
12 li = list(range(10))
13 random.shuffle(li)
14 print(li)
15 select_sort(li)
16 print(li)

選擇排序

 4、時間複雜度：O(n2)

三、插入排序

1、思路：元素被分為有序區和無序區兩部分。最初有序區只有一個元素。每次從無序區中選擇一個元素，插入到有序區的位置，直到無序區變空。

2、程式碼關鍵點：

• 摸到的牌
• 手裡的牌

3、圖示說明

插入後：

4、程式碼示例

 1 import random
 2 def insert_sort(li):
 3     for i in range(1,len(li)):
 4         #i 表示無序區的第一個數
 5         tmp = li[i]  #摸到的牌
 6         j = i-1 #指向有序區最後一個位置
 7         while li[j] >tmp and j>=0:
 8             #迴圈終止條件 li[j]<=tmp  and j==-1
 9             li[j+1] = li[j]  #向後移動
10             j-=1
11         li[j+1] = tmp
12         
13 li = list(range(10))
14 random.shuffle(li)
15 print(li)
16 insert_sort(li)
17 print(li)

插入排序

四、快速排序

1、思路：1、取一個元素p(第一個元素)，是元素p歸位（去它該去的地方）；

　　　　　2、列表被p分成兩部分，左邊的都比p小，右邊的都比p大；

　　　　　3、遞迴完成排序

2、演算法關鍵點

• 歸位
• 遞迴

3、圖示說明

4、怎麼歸併呢？先把5取出來，這時候就會有一個空位，從右邊找比5小的數填充過來，現在右邊有一個空位了，從左邊找比5大的放到右邊的空位上。依次類推，

只要left和right碰在一起，這樣就找打5的位置了

如圖示：

圖一圖二

 圖三圖四

 這樣在把找到的5的位置放進去去ok了

5、程式碼示例

 1 import time
 2 def wrapper(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         ret = func(*args,**kwargs)
 6         end = time.time()
 7         print('%s running time :%s'%(func.__name__,start-end))
 8         return ret
 9     return inner
10 
11 
12 def partition(li,left,right):
13     '''歸位函式'''
14     tmp = li[left]  #先把5取出來
15     while left < right:
16         while left < right and li[right] >= tmp:  #如果降序排列修改li[right] <= tmp
17                 right -= 1 #從右邊找比5小的數，填充到5的位置
18         li[left] = li[right]
19         while left < right and li[left] <= tmp:  #如果降序排列修改li[right] >= tmp
20                 left += 1# 從左邊找比5大的數字放在右邊的空位
21         li[right] = li[left]
22     li[left] = tmp  #當跳出迴圈條件的時候說明找到了，並且把拿出來的5在放進去
23     return left
24 
25 
26 def _quick_sort(li,left,right):
27     '''快速排序的兩個關鍵點：歸位，遞迴'''
28     if left < right:  #至少有兩個元素，才能進行遞迴
29         mid = partition(li,left,right)  #找到歸位的位置
30         _quick_sort(li,left,mid-1)  #遞迴，右邊的-1
31         _quick_sort(li,mid+1,right) #遞迴，左邊的+1
32 
33 @wrapper
34 def quick_sort(li):
35     return _quick_sort(li, 0, len(li)-1)
36 
37 @wrapper
38 def sys_sort(li):
39     '''系統排序'''
40     li.sort()
41 
42 import random
43 li = list(range(100000))
44 random.shuffle(li)
45 # print(li)
46 quick_sort(li)
47 # print(li)
48 
49 sys_sort(li)  
50 
51 #結論：系統的排序要比快排的時間快的多
52 # quick_sort running time :-0.6240355968475342
53 # sys_sort running time :-0.002000093460083008

快速排序演算法

6、快速排序的時間複雜度O(nlogn)

五、堆排序

有關對的瞭解：http://www.cnblogs.com/haiyan123/p/8400537.html

1、堆排序過程：

• 1、建立堆
• 2、得到堆頂元素，為最大元素
• 3、去掉堆頂，將堆最後一個元素放在堆頂，此時可通過一次調整重新使堆有序
• 4、堆頂元素為第二大元素
• 5、重複步驟3，直到堆變空

程式碼示例

 1 import random
 2 
 3 def _sift(li, low, high):
 4     """
 5     :param li:
 6     :param low: 堆根節點的位置
 7     :param high: 堆最有一個節點的位置
 8     :return:
 9     """
10     i = low  # 父親的位置
11     j = 2 * i + 1  # 孩子的位置
12     tmp = li[low]  # 原省長
13     while j <= high:
14         if j + 1 <= high and li[j + 1] > li[j]:  # 如果右孩子存在並且右孩子更大
15             j += 1
16         if tmp < li[j]:  # 如果原省長比孩子小
17             li[i] = li[j]  # 把孩子向上移動一層
18             i = j
19             j = 2 * i + 1
20         else:
21             li[i] = tmp  # 省長放到對應的位置上(幹部)
22             break
23     else:
24         li[i] = tmp  # 省長放到對應的位置上(村民/葉子節點)
25 
26 
27 def sift(li, low, high):
28     """
29     :param li:
30     :param low: 堆根節點的位置
31     :param high: 堆最有一個節點的位置
32     :return:
33     """
34     i = low         # 父親的位置
35     j = 2 * i + 1   # 孩子的位置
36     tmp = li[low]   # 原省長
37     while j <= high:
38         if j + 1 <= high and li[j+1] > li[j]: # 如果右孩子存在並且右孩子更大
39             j += 1
40         if tmp < li[j]: # 如果原省長比孩子小
41             li[i] = li[j]  # 把孩子向上移動一層
42             i = j
43             j = 2 * i + 1
44         else:
45             break
46     li[i] = tmp
47 
48 
49 
50 def heap_sort(li):
51     n = len(li)
52     # 1. 建堆
53     for i in range(n//2-1, -1, -1):
54         sift(li, i, n-1)
55     # 2. 挨個出數
56     for j in range(n-1, -1, -1):    # j表示堆最後一個元素的位置
57         li[0], li[j] = li[j], li[0]
58         # 堆的大小少了一個元素 （j-1）
59         sift(li, 0, j-1)
60 
61 
62 li = list(range(10))
63 random.shuffle(li)
64 print(li)
65 heap_sort(li)
66 print(li)
67 
68 # li=[2,9,7,8,5,0,1,6,4,3]
69 # sift(li, 0, len(li)-1)
70 # print(li)

堆排序

六、歸併排序

假設現在的列表分兩段有序，如何將其合成為一個有序列表。這種操作稱為一次歸併

1、思路：

2、歸併關鍵字

• 分解：將列表越分越小，直至分成一個元素
• 終止條件：一個元素是有序的
• 合併：將兩個有序列表歸併，列表越來越大

3、圖實示例：https://www.cnblogs.com/chengxiao/p/6194356.html

4、程式碼示例：

 1 import random
 2 def merge(li, low, mid, high):
 3     # 一次歸併
 4     '''
 5     :param li: 列表
 6     :param low: 起始位置
 7     :param mid: 按照那個位置分
 8     :param high: 最後位置
 9     :return:
10     '''
11     i = low
12     j = mid + 1
13     ltmp = []
14     while i <= mid and j <= high:
15         if li[i] < li[j]:
16             ltmp.append(li[i])
17             i += 1
18         else:
19             ltmp.append(li[j])
20             j += 1
21     while i <= mid:
22         ltmp.append(li[i])
23         i += 1
24     while j <= high:
25         ltmp.append(li[j])
26         j += 1
27     li[low:high+1] = ltmp
28 
29 
30 def _merge_sort(li, low, high):
31     if low < high:  # 至少兩個元素
32         mid = (low + high) // 2
33         _merge_sort(li, low, mid)
34         _merge_sort(li, mid+1, high)
35         merge(li, low, mid, high)
36         print(li[low:high+1])
37 
38 
39 def merge_sort(li):
40     return _merge_sort(li, 0, len(li)-1)
41 
42 
43 li = list(range(16))
44 random.shuffle(li)
45 print(li)
46 merge_sort(li)
47 
48 print(li)

歸併排序

5、歸併排序的時間複雜度：O(nlogn)，空間複雜度是：O(n)

總結：

LOw B 三人組

• 氣泡排序，選擇排序，直接插入排序他們的時間複雜度都是O(n^2),空間複雜度是O(1)

NB 三人組

• 快速排序，歸併排序，堆排序他們的時間複雜度都是O(nlogn)
• 三種排序演算法的缺點
  • 快速排序：極端情況下排序效率低
  • 歸併排序：需要額外的記憶體開銷
  • 堆排序：在快的排序演算法中相對較慢

挨著換的穩定，不挨著換的不穩定