排序算法

冒泡排序

#将列表元素中最大值找出放置在了列表中最后的位置
def sort(alist):
    for i in range(0,len(alist)-1):
        if alist[i] > alist[i+1]:
            alist[i],alist[i+1] = alist[i+1],alist[i]
            
    print(alist)


def sort(alist):
    for j in range(0,len(alist)-1):
        
        for i in range(0,len(alist)-1-j): #空值比较的次数
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
            
    print(alist)


alist = [4,11,6,8,2,9]
sort(alist)

选择排序

#1.直接将列表中最大值找出，放在列表最后的位置
def sort(alist):
    max = 0 #max中存储的是列表中元素值最大的数的下标。最开始先假设列表下标为0对应的元素是最大值
    for i in range(0,len(alist)-1):
        if alist[max] < alist[i+1]:
            max = i+1
    #将最大值放置到列表末尾的位置
    alist[max],alist[len(alist)-1] = alist[len(alist)-1],alist[max]
    print(alist)


#最终
def sort(alist):
    for j in range(len(alist)-1,0,-1):#5,4,3,2,1
        
        max = 0 #max中存储的是列表中元素值最大的数的下标。最开始先假设列表下标为0对应的元素是最大值
        for i in range(0,j):#len(alist)-1  ==> j
            if alist[max] < alist[i+1]:
                max = i+1
        #将最大值放置到列表末尾的位置
        alist[max],alist[j] = alist[j],alist[max]
    print(alist)

alist = [4,11,6,88,2,9]
sort(alist)

插入排序

alist = [3,8,5,7,6]

[3, 8,5,7,6]
[3,8, 5,7,6]
[3,5,8, 7,6]
[3,5,7,8, 6]
[3,5,6,7,8 ]

#step_1
i = 1#表示的是列表中左部分有序部分的数据个数，其次还需要让i充当列表的下标
#alist[i] == 8,乱序部分的第一个数据
#alist[i-1] == 3，有序部分的第一个数据
if alist[i] < alist[i-1]:
    alist[i],alist[i-1] = alist[i-1],alist[i]
    i += 1

#step_2
i = 2
#alist[i]乱序部分的第一个数据
#alist[i-1]:有序部分的第二个数
while i >= 1:
    if alist[i] < alist[i-1]:
        alist[i],alist[i-1] = alist[i-1],alist[i]
        i -= 1
    else:
        break

#step_3
for i in range(1,len(alist)+1):
    #alist[i]乱序部分的第一个数据
    #alist[i-1]:有序部分的第二个数
    while i >= 1:
        if alist[i] < alist[i-1]:
            alist[i],alist[i-1] = alist[i-1],alist[i]
            i -= 1
        else:
            break

#完整的代码
def sort(alist):
    for i in range(1,len(alist)):
        #alist[i]乱序部分的第一个数据
        #alist[i-1]:有序部分的第二个数
        while i >= 1:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
    print(alist)


alist = [4,11,6,88,2]
sort(alist)

 

希尔排序：特殊的插入排序，或者说插入排序就是增量为1的希尔排序

#step_1: 增量为1的希尔排序
gap = 1
for i in range(1,len(alist)):
        #alist[i]乱序部分的第一个数据
        #alist[i-1]:有序部分的第二个数
        while i >= 1:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
    print(alist)

##step_1: 实现了增量为gap的希尔排序 == （插入排序）
gap = len(alist)//2
for i in range(gap,len(alist)):
        #alist[i]乱序部分的第一个数据
        #alist[i-1]:有序部分的第二个数
        while i >= 1:
            if alist[i] < alist[i-gap]:
                alist[i],alist[i-gap] = alist[i-gap],alist[i]
                i -= gap
            else:
                break
    print(alist)


#step_2: 
gap = len(alist)//2
while gap >= 1:
    for i in range(gap,len(alist)):
            #alist[i]乱序部分的第一个数据
            #alist[i-1]:有序部分的第二个数
            while i >= 1:
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= gap
                else:
                    break
    gap //= 2
print(alist)

#最终代码
def sort(alist):
    gap = len(alist)//2
    while gap >= 1:
        for i in range(gap,len(alist)):
                #alist[i]乱序部分的第一个数据
                #alist[i-1]:有序部分的第二个数
                while i >= 1:
                    if alist[i] < alist[i-gap]:
                        alist[i],alist[i-gap] = alist[i-gap],alist[i]
                        i -= gap
                    else:
                        break
        gap //= 2
    print(alist)


alist = [4,1,5,2,7,9,3]
sort(alist)

快速排序

- 设定一个基数，就是原始列表中第0个列表元素的数据值，基数需要存储在一个mid的变量中

- 设定两个变量一个为low（对应列表第一个数据的下标），一个为high（对应列表最后一个数据的下标）

- 从右开始偏移high，需要将high的指向的数据跟基数进行大小比较，如果high指向的数值大于基数，则让high向左偏移一位，继续进行比较，直到high指向的数值小于了基数，则停止high的偏移，将high指向的数值放置到low的位置，然后开始偏移low

- 从左往右偏移low，如果low指向的数值小于基数，则将low向右偏移一位，如果low指向的数值大于了基数，则停止low的偏移，且将low指向的数值赋值到high的位置，然后继续偏移high

- 当low和high重复相遇后，将基数赋值到low或者high指向的位置

def sort(alist,start,end):
    low = start
    high = end
    
    if low > high:
        return
    
    mid = alist[low]
    while low < high:
        while low < high:
            if alist[high] > mid:#将high向左偏移
                high -= 1
            else:
                alist[low] = alist[high]
                break

        while low < high:
            if alist[low] < mid:#向右移动low
                low += 1
            else:
                alist[high] = alist[low]
                break
            
    if low == high:
        alist[low] = mid#alist[high] = mid
        
    #将sort的操作作用到基数左侧部分
    sort(alist,start,low-1)
    #将sort的操作作用的基数右侧部分
    sort(alist,high+1,end)
    
    return alist



alist = [6 ,1, 2, 7, 9, 3, 4, 5, 10, 8]
alist = sort(alist,0,len(alist)-1)
print(alist)