那些經典排序演算法復現 Python

演算法簡介：

在給定陣列中，找到那個最小的數，與第乙個元素交換位置，如果第乙個元素就是最小的，那就和本身交換，然後在交換後的陣列中，繼續尋找最小的，和第二個元素交換，以此類推，每次都選擇那個最小的數

故曰，選擇排序

少廢話，上**：

class
selection
:def
sort
(self, nums)
:# 外層迴圈，指定內層迴圈找到的最小值要交換到的位置
for i in
range
(len
(nums)):
idx_min_value = i # 假設最小值的索引就在最開始
# 內層迴圈，找到那個最小值，並將索引，重新賦值
for j in
range
(i+1
,len
(nums)):
if nums[j]
< nums[idx_min_value]
:                    idx_min_value = j
# 交換數值
nums[i]
, nums[idx_min_value]
= nums[idx_min_value]
, nums[i]
return nums

演算法簡介：

可能是，這種演算法的提出，**於人們在整理撲克時，如果想要牌的大小，按照從左至右，依次公升序的順序排列的話，會每次找到那張小的數值的牌，然後將它插入到左面去。依次類推，每次左面都是排好序的，遍歷到最後乙個的時候，順序就排好了

少廢話，上**：

class
insert
:def
sort
(self, nums)
:# 外層迴圈，指定將要比較的數，也就是被插入數
for i in
range(1
,len
(nums)):
j = i
# 內層迴圈， 遇到前面，也就是左面，有大的，要交換數值
while j >0:
if nums[j]
< nums[j-1]
:                    nums[j]
, nums[j-1]
= nums[j-1]
, nums[j]
j -=
1return nums

演算法簡介：

此演算法是基於上述的插值排序的改進版本，基本思想是，因為插值排序，是每次比較之後，每次只移動乙個位置，這樣的話，如果最小的數，排在整個陣列的最後面，那麼就要移動n-1次

故，提出了一種演算法是預先設定了乙個移動距離h，先按照這個距離將陣列分成以h為間距的子陣列，先將以h為間距的子陣列首尾（其實間距在大於1時，每次只比較排序首尾的元素）排好序

最後在按照插值排序的方法，整體排序

少廢話，上**：

def
shellsort
(nums)
:# 定義欲排序子陣列的長度間距，簡單設定為陣列的一半
h =len(nums)//2
# 最外層迴圈控制子陣列長度間距，逐步遞減，最後減至1時
# 即為插值排序
while h >=1:
# 開始排序以h為間距的子陣列的順序
for i in
range
(h,len
(nums)):
j = i # 設定乙個變數，用於比較，交換數值的索引
# 當滿足插值排序的條件時，即前乙個比後乙個大,交換
while j >= h and nums[j-h]
> nums[j]
:                nums[j-h]
, nums[j]
= nums[j]
, nums[j-h]
j -= h # 設定迴圈結束條件
h = h //
2# 每次間距縮小它的一半，最後至1，即插值排序
return nums

演算法簡介：

中心思想就是假設如果你得到兩個已經排好順序的子陣列，比如[3, 4]和[1, 2]，原陣列是[2, 1, 4, 3].那麼你直接可以用乙個歸併函式，將這兩個歸併成有序的大陣列，替代原來的那個，即[1, 2, 3, 4]

如何在給定乙個無序的大陣列的情況，得到排好順序的子陣列，可以設計乙個遞迴，你設定乙個變數，作為切分子陣列的邊界，然後遞迴下去，遞迴停止的條件就是當子陣列的長度為1時，因為那個時候陣列已經排好順序了

在遞迴觸底之後，兩個子陣列的長度為1啊，就呼叫提前編寫的歸併函式，為之排序，直至最後全部排好序

少廢話，上**：

# 首先定義乙個歸併函式
# 作用是使兩個有序的子陣列，歸併成乙個有序的大陣列
defmerge
(nums1, nums2, nums)
:# 定義兩個所謂的指標，分別指向兩個有序子陣列的開頭
# n為欲合併成大陣列的長度
i, j, n =0,
0,len(nums1)
+len
(nums2)
# 開始排序，k表示那個大陣列的索引，乙個乙個換成正確的數
for k in
range
(n):
# 下面四種選擇，也就是如何將兩個都有序的子陣列，合併成乙個大陣列
# 設定一下合適的條件，即可實現這個功能
if i >
len(nums1)-1
:            nums[k]
= nums2[j]
j +=
1elif j >
len(nums2)-1
:            nums[k]
= nums1[i]
i +=
1elif nums1[i]
< nums2[j]
:            nums[k]
= nums1[i]
i +=
1else
:            nums[k]
= nums2[j]
j +=
1# 開始定義歸併排序函式
defmergesort
(nums)
:# 設定遞迴停止條件，只剩乙個元素的時候，就停止
# 因為那已經是有序的了
iflen
(nums)
<2:
return
mid =
len(nums)//2
# 設定開始向下遞迴的子陣列的邊界
nums1 = nums[
0:mid]
# 欲歸併的子陣列
nums2 = nums[mid:
len(nums)
]# 開始遞迴下去，把大陣列分成乙個乙個的小子陣列
mergesort(nums1)
mergesort(nums2)
# 使有序的子陣列，呼叫歸併函式，歸併成乙個大陣列
merge(nums1, nums2, nums)

演算法簡介：

首先它是乙個原地排序的方法，也可能是目前應用最廣泛的排序演算法

具體的思路和邏輯是，在乙個給定的欲排序的陣列中，先隨機選擇乙個數，作為欲排定的數，因為在執行完一遍快速排序的邏輯之後，那個隨機選擇的數，就正好在它的正確位置了

而且在那個欲排定的數的左邊，全是比它小的數，它的右邊，全是比它大的數，但左右兩邊的陣列很可能是無序的

這樣執行一遍下來，我們就排序好了乙個數，就是我們預先隨機選擇的那個數

接下來，就是對已經排序好的那個數的左右兩邊，繼續用同樣的方法，遞迴的方式，繼續排序，直到符合我們設定的遞迴的停止條件，停止以後，排序即完成

少廢話，上**：

def
quicksort
(nums, left, right)
:# 設定遞迴停止條件，當需要排序的元素只有乙個的時候
# 自己給自己賦值後，就停止
if left > right:
return
0    v = nums[left]
# 每次預設將要排序的陣列的第乙個元素，作為要排定的元素
i, j = left, right # 設定兩個移動的指標
# 設定外層迴圈終止條件，即左右兩個指標相遇時
while i != j:
# 先由右邊向左邊去尋找，找那個比預設值小的元素
# 同時不能越界，不能越過i
# 由快速排序的定義可知，最後要將預設值v
# 與它正確的位置的那個元素進行原地交換
# 所以我們先從右向左進行，以便保證i=j時，停留的位置
# 就剛好是預設值，正確所在位置
while nums[j]
> v and i < j:
j -=
1# 然後，開始從左向右去尋找，那個比預設值大的元素
while nums[i]
<= v and i < j:
i +=
1# 要保證i和j在未相遇之前，做大小值得交換
# 也是符合快速排序的邏輯
if i < j:
nums[i]
, nums[j]
= nums[j]
, nums[i]
# 當迴圈終止時，也就是i，j相遇時
# 說明此時索引i的左面，全部是小於等於預設值v的數
# 索引i的右面，全部是大於預設值v的數
# 索引i的位置，就是預設值v的正確位置
nums[left]
, nums[i]
= nums[i]
, nums[left]
# 下面開始用同樣的方法，以遞迴的方式去排序剩餘的數
quicksort(nums, left, i-1)
quicksort(nums, i+
1, right)

那些經典排序演算法復現 Python

排序演算法氣泡排序演算法分析與實現 Python

排序演算法選擇排序演算法分析與實現 Python

經典排序演算法

那些經典排序演算法復現 Python

排序演算法 氣泡排序演算法分析與實現 Python

排序演算法 選擇排序演算法分析與實現 Python

經典排序演算法

相關推薦

排序演算法氣泡排序演算法分析與實現 Python

排序演算法選擇排序演算法分析與實現 Python