python排序---冒泡-选择

s = [1,9,8,5,6,7,4,3,2]
s = [9,8,7,6,6,4,3,2,1]
length = len(s)


count = 0
swap_count =0
for i in range(length-1):  #第几趟
    flag = False  ###判断每一趟是否有交换,没有交换意味队列已经拍好序了。
                   ### ***冒泡法的优化点***
                   ### 遍历次数 1+2+...+n-1 = n(n-1)/2
    for j in range(length-1-i): ##两两比较(每次能多固定一个数位置,不用再次比较), 用极限2个元素判断索引边界,防止越界
        count += 1
        if s[j] > s[j+1]: 
            tmp = s[j]
            s[j] = s[j+1]
            s[j+1] = tmp
            swap_count += 1
    if not flag:
        break
print(s, count, swap_count)

A = [1,9,8,5,6,7,4,3,2]
count_i = 0
count_s = 0
#tmp =0
for i in range(len(A)):
    maxi = i
    for j in range(i+1,len(A)):
        count_i += 1
        if A[j] > A[max]:
            max = j
    #print(A[max])
    #tmp = A[i]
    #A[i] = A[max]
    #A[max] = tmp
    if maxi != i:
        A[maxi],A[i] = A[i],A[maxi]  ###交换值,解构
        count_s += 1
print(A)
print(count_i, count_s)

A = [1,9,8,5,6,7,4,3,2]
length = len(A)

for i in range(length//2):
    maxi = i
    mini = -i-1
    for j in range(i+1,length-i):  ###右边是固定最小值区域,后面max和min就不用再次比较该区域的值了
        if A[j] > A[maxi]:
            maxi = j
        if A[-j-1] < A[mini]:
            mini = -j-1
    if A[maxi] == A[mini]:  ###说明后面的值是一样的
        break
    
    if maxi != i:
        A[maxi],A[i] = A[i],A[maxi]  ###交换值,解构
        if i == mini or mini == i - length:###防止前面的交换值
            mini = maxi - length  ###改为负索引,防止后面的自己修改自己
    if mini != -i-1:
        A[mini],A[-i-1] = A[-i-1],A[mini]
    #A[max],A[i],A[min],A[-i-1] = A[i],A[max],A[-i-1],A[min]
        
print(A)