【排序】冒泡， 選擇， 插入

一，冒泡排序

    1.屬於交換排序

    a. 比較相鄰的倆個數據，如果第二個數小，就交換位置

    b. 從後向前兩兩比較，一直到比較最前兩個數據。最終最小數被交換到起始的位置，這樣第一個最小數的位置就排好了。

    c. 繼續重複上述過程，依次將第2.3.....n-1個最小的數排好位置。

    2.平均時間複雜度： O(n2)

    

num_list = [
    [1,9,8,5,6,7,4,3,2],
    [1,2,3,4,5,6,7,8,9]
]
nums = num_list[1]
print (nums)
length = len(nums)
count_swap = 0
count = 0
for i in range (length):
    for j in range (length-i-1):
        count += 1
        if  nums [j]>nums [j+1]:
            nums [j], nums[j+1]=nums[j+1], nums[j]
            count_swap += 1
print (nums,count_swap,count)

算法優化：

設置標誌位flag,如果發生了就交換flag設置爲true 如果沒有交換就設置爲False

這樣當一輪比較結束後裔如果還沒flag 還是 false,表示這一輪沒有發生交換，說明數據的順序已經排好，就沒有必要經行下去了。

num_list = [
    [1,9,8,5,6,7,4,3,2],
    [1,2,3,4,5,6,7,8,9],
    [1,2,3,4,5,6,7,9,8]
]
nums = num_list[2]
print (nums)
length = len(nums)
count_swap = 0
count = 0
for i in range (length):
    flag = False
    for j in range (length-i-1):
        count += 1
        if  nums [j]>nums [j+1]:
            nums [j], nums[j+1]=nums[j+1], nums[j]
            flag = True
            count_swap += 1
    if not flag:
        break
print (nums,count_swap,count)

二，選擇排序：

    1.屬於交換排序

    a. 在長度爲N的無序數組中，第一次遍歷n-1個數，找到最小的數值與第一個元素交換：

        在第二次遍歷 n-2 個數，找到最小的數值與第二個元素交換。。。。。。

        第 n-1 次遍歷，找到最小的數值與第 n-1個元素交換，排序完成。

    2.平均時間複雜度 ; O(n2)

m_list =[
    [1,9,8,5,6,7,4,3,2],
    [1,2,3,4,5,6,7,8,9],
    [9,8,7,6,5,4,3,2,1]
]
nums = m_list[2]
length = len (nums)
print (nums)
count_swap = 0
count_iter = 0
for i in range (length ):
    maxindex = i
    for j in range ( i + 1,length):
        count_iter += 1
        if nums[maxindex] < nums[j]:
            maxindex = j
    if i != maxindex:
        nums [i] ,nums [maxindex] = nums [maxindex],nums[i]
        count_swap +=1
print (nums,count_swap,count_iter)

優化寫法：

二元選擇排法

m_list =[
    [1,9,8,5,6,7,4,3,2],
    [1,2,3,4,5,6,7,8,9],
    [9,8,7,6,5,4,3,2,1],
    [1,1,1,1,1,1,1,1,1]
]
nums = m_list[1]
length = len (nums)
print (nums)
count_swap = 0
count_iter = 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[maxindex] < nums[j]:
            maxindex = j
        if nums[minindex] > nums [-j -1]:
            minindex = -j -1
    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
    if minorigin != minindex :
        nums [minorigin],nums[minindex]=nums[minindex],nums[minorigin]
        count_swap += 1 
print (nums,count_swap,count_iter)

三，插入排序

    1.交換排序

    a. 增加一個哨兵位，每輪比較將待比較數放入

    b. 哨兵依次和待比較數的前一個數據比較，大數靠右移動，找到哨兵中值得插入位置

    c. 每一輪結束後，得到一個從開始到待比較數位置的一個有序序列

    2.平均時間複雜度;O(n2)

origin = [1,9,8,5,6]
nums = [0] + origin #創建新的列表
length = len (nums )
for i in range (2,length ):#第一位沒有必要比較，所以從索引開始比較
nums [0] = nums [i] #創建哨兵
j = i -1   #跟自己左面比較，關鍵比較
if nums [j] > nums [0]:#開始向右移動
while  nums [j] > nums [0]:#整個移動的過程
nums [j+1] = nums [j]
j -= 1   #跟自己左面比較
nums [j+1] = nums [0]#哨兵歸位，補到空的位置
print  (nums)  #因爲哨兵還在第一位  所以沒有必要從第一個開始
print  (nums [1:])