【排序】冒泡， 选择， 插入

一，冒泡排序

    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:])