用一個Python簡單選擇排序算法，鍛鍊編碼內功

Python簡單排序算法：

• 在每一趟的比較過程中（與冒泡不同），只比較，不交換位置；
• 遍歷次數n(n-1)/2；
• 時間複雜度O(n**2)；
• 與冒泡相比較，減少了交換次數，性能提高。

1.1 Python簡單快速排序的核心算法：

• 結果可爲升序或降序排列，默認升序排列
• 擴大有序區，減小無序區。圖中紅色部分就是增大的有序區，反之就是減小的無序區
  以降序爲例
• 相鄰元素依次兩兩比較，獲得每一次比較後的最大值，並記住此值的索引
  -每一趟都從無序區中選擇出最大值，然後交換到當前無序區最左端
  算法實現

nums = [1,9,8,5]
length = len(nums)

for i in range(length-1): #比較的次數與冒泡排序一樣，len(nums)-1 次。
    maxindex = i
    for j in range(i+1,length):
        if nums[j]>nums[maxindex]:
            maxindex = j
    nums[i],nums[maxindex] = nums[maxindex],nums[i]
        
    print(nums,i,maxindex)
#     if i == 0: break
#     if i == 1: break
#     if i == 2: break
#     if i == 3: break
        
    

[9, 1, 8, 5] 0 1
[9, 8, 1, 5] 1 2
[9, 8, 5, 1] 2 3

優化當最大值已經是第一個時候，無需再排序的情況。

nums = [9,1,8,5]
 
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length-1):  
    maxindex = i
    for j in range(i+1,length):
        count_iter += 1
        if nums[j]>nums[maxindex]:
            maxindex = j
    
    if i !=maxindex: # 這說明i自己就是maxindex
        count_swap += 1
        nums[i],nums[maxindex] = nums[maxindex],nums[i]
        
    print("結果{}；比較次數{:>3}，交換次數{:>3}".format(nums,count_iter,count_swap))

結果[9, 1, 8, 5]；比較次數  3，交換次數  0
結果[9, 8, 1, 5]；比較次數  5，交換次數  1
結果[9, 8, 5, 1]；比較次數  6，交換次數  2

1.2 Python簡單快速排序的比較次數減少和末次交換減少：

這個方法要注意避免最大值交換後會對最小值交換是的索引產生影響，如何規避這個影響是關鍵。

nums_list = [[1,9,8,5],[9,1,8,5]]
nums = nums_list[0]

length = len(nums)

count_iter = 0
count_swap = 0
 
for i in range(length // 2):  
    maxindex = i
    minindex = -i -1 
    minoriginal = minindex
 
    for j in range( i+1 ,length -i):
        count_iter += 1
        
        if nums[j]>nums[maxindex]:
            
            maxindex = j
        if nums[minindex]>nums[-j -1]: 
 
            minindex = -j -1 # $從-2開始的倒序取索引

   
    if i !=maxindex: # 這說明i自己就是maxindex
        nums[i],nums[maxindex] = nums[maxindex],nums[i]
        count_swap += 1
        # 客服交換對最小值索引的干擾 
        if i == minindex or i == length + minindex: #>>>>>>>>>>>>>>>>>>>>>
            minindex = maxindex - length #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    if minoriginal!=minindex:
        nums[minoriginal],nums[minindex] = nums[minindex],nums[minoriginal]
        count_swap +=1
    print(nums,i,maxindex)
    break

        
print("結果{}；比較次數{:>3}，交換次數{:>3}".format(nums,count_iter,count_swap))

[9, 5, 8, 1] 0 1
結果[9, 5, 8, 1]；比較次數  3，交換次數  2

nums_list = [[1, 9, 8, 5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length):
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i] #這裏的索引變化是會對下面的minindex產生影響的，所以本次的輸出是錯誤的
        count_swap += 1
    if minorigin != minindex:
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 9, 8, 5]
1 -4 ++
[5, 1, 8, 9] 0 1
3 -3 ++
[5, 8, 9, 1] 1 3
______________________________
[5, 8, 9, 1] 5 4

修正後的版本，這裏用到了負索引的技巧：

nums_list = [[1, 9, 8, 5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length):
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i] #這裏的索引變化是會對下面的minindex產生影響的，所以本次的輸出是錯誤的
        count_swap += 1
    if  i == minindex or i == length + minindex:# 解決方案
        minindex = maxindex - length      # 把正索引換位負索引

        if minorigin != minindex:
            nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
            count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 9, 8, 5]
1 -4 ++
[9, 5, 8, 1] 0 1
2 -3 ++
[9, 8, 5, 1] 1 2
______________________________
[9, 8, 5, 1] 5 3

補充校正內循環次數：

nums_list = [[1,8,1,1,1,1,1,9,5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length-i): #每次內循環前後各減少一個
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i] #這裏的索引變化是會對下面的minindex產生影響的，所以本次的輸出是錯誤的
        count_swap += 1
    if  i == minindex or i == length + minindex:# 解決方案
        minindex = maxindex - length      # 把正索引換位負索引

    if minorigin != minindex:
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 8, 1, 1, 1, 1, 1, 9, 5]
7 -3 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 0 7
1 -2 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 1 1
6 -4 ++
[9, 8, 5, 1, 1, 1, 1, 1, 1] 2 6
3 -4 ++
[9, 8, 5, 1, 1, 1, 1, 1, 1] 3 3
______________________________
[9, 8, 5, 1, 1, 1, 1, 1, 1] 20 4

最後的優化，當極大值和極小值相遇。

nums_list = [[1,8,1,1,1,1,1,9,5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length-i): # 
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")
    
    if nums[maxindex] == nums[minindex]:  # 避免 有重複數據的情況的內循環浪費
        break

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i]    
        count_swap += 1
    if  i == minindex or i == length + minindex:#  
        minindex = maxindex - length      #  

    if minorigin != minindex:
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 8, 1, 1, 1, 1, 1, 9, 5]
7 -3 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 0 7
1 -2 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 1 1
6 -4 ++
[9, 8, 5, 1, 1, 1, 1, 1, 1] 2 6
3 -4 ++
______________________________
[9, 8, 5, 1, 1, 1, 1, 1, 1] 20 4

最後，通過增加值的判斷，完善一種無需排序的情況：

nums_list = [[2,1,1,1,1], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length-i): # 
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")
    
    if nums[maxindex] == nums[minindex]:  
        break

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i]    
        count_swap += 1
    if  i == minindex or i == length + minindex:#  
        minindex = maxindex - length      #  

    if minorigin != minindex and nums[minindex] != num[min]: # 增加條件，如果值相等，就也不交換
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[2, 1, 1, 1, 1]
0 -1 ++
[2, 1, 1, 1, 1] 0 0
1 -2 ++
______________________________
[2, 1, 1, 1, 1] 6 0

附 變體

li = [2, 3, 1, 7, 65]
for i in range(len(li) - 1):
    max = li[i]

    for j in range(i + 1, len(li)):

        if max < li[j]:
            max = li[j]
            max_index=j
    li[max_index]=li[i]
    li[i], max = max, li[i]
    print(li)
print(li)

[65, 3, 1, 7, 2]
[65, 7, 1, 3, 2]
[65, 7, 3, 1, 2]
[65, 7, 3, 2, 1]
[65, 7, 3, 2, 1]