冒泡，选择，插入，快速排序

冒泡排序

• 第一步，确定躺数
• 第二部，每次减去已经排好的部分
• 第三步，开始排序，满足条件，交换位置
• 第四步，加入开关，如果本次排序后的结果和上一次相同，则证明已经排好，可以停止

def buttle_sort(li):
    for i in range(len(li)-1):
        exc = False
        for k in range(len(li)-1-i):
            if li[k] > li[k+1]:
                li[k],li[k+1] = li[k+1],li[k]
                exc = True
        print(li)
        if not exc:
            break

li = [9,8,7,1,2,3,4,5,6]
buttle_sort(li)
print(li)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

选择排序

• 第一步，确定躺数,最后一个数据不用再排
• 第二部，假设每一趟的第一个数是最小值,用下标来定义
• 第三步，用第一个数后的每一个数和第一个数比较，找到最小的值的下标
• 第四步，在每一趟结束的时候可以得到一个最小值的下标，用来和第一个数进行交换

def select_sort(li):
    for i in range(len(li)-1):
        min_num = i
        for k in range(i+1,len(li)):
            if li[k] < li[min_num]:
                min_num = k
        li[i],li[min_num] = li[min_num],li[i]

li = [9,8,7,1,2,3,4,5,6]
select_sort(li)
print(li)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

插入排序

• 第一步确定躺数，默认将第一张牌拿出来作为已经抽到的，从第二张牌开始循环
• 第二部，每次抽到的一张牌，同手里的牌依次比较，从最后往前比，如果这张牌比手里的牌要小，手里当前的牌就往右移一位，当遇到比抽中的牌小的牌，或者比较了所有的牌都没有找到比抽中的牌小，那么也就确定了抽中的牌的位置，应当停止循环
• 把抽中这张牌放入到当前的位置

def insert_sort(li):
    for i in range(1,len(li)):  #躺数，第一步
        temp = li[i]  #当前抽中的牌  ，第二部开始
        j = i - 1  #当前手中最大（最后）一张牌的下标
        while j >= 0 and li[j] > temp:  #若是手里面有牌并且抽中的牌也大于手里当前位置的牌，那就停止循环，返回当前比抽中的牌小的牌的下标
            li[j+1] = li[j]   #比抽中的牌大的往后移动一位，也就是下一位的数等于当前位置的数
            j -= 1   #没有数比抽中的数小时，一位着j=-1,i=0，就应该把抽中的牌放到最前面的位置
        li[j+1] = temp   #循环结束的时候，J会返回一个值，就是比抽中的牌小的牌的下标，那抽中的牌应该放在它的后面

li = [9,8,7,1,2,3,4,5,6]
insert_sort(li)
print(li)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

快速排序

• 取一个元素p(一般是第一个元素)，使元素p回到回到它的大小合适的地方
• 列表被元素p分割为两部分。左边都比p小，右边都比p大
• 将上一步的逻辑分别运用于左右的两部分，递归，直到排序完成

#先做出来一个功能，一次次的将列表细分，左右分组
def partition(li, left, right): #li传入列表，left列表起始位置（第一个）, right 列表结束位置
    temp = li[left]  #定义是将第一个拿出，这是第一个值的位置就空了
    while left < right: #整体是建立在left < right的基础上进行的
        while left < right and li[right] >= temp:  #找到比temp小的数 ；left<right 当left 和right相等的时候就说明 temp已经找到适合它的位置，这个时候数据也就分成了左右两边，就必须停止了，否则就超出了界限
            right -= 1   # 第一个值被拿走后，位置就空了，从最后往前找比temp小的值，找到一个right的指针就往回缩一个
        li[left] = li[right] #循环结束后，right会得到第一个比temp小的值的位置，把当前位置的值移到第一个空中，这时当前位置就成空的了

        while right > left and li[left] <= temp:  #这时右边出现一个空值，那么就从左边找出一个比temp大的值，移动到这个空位置
            left += 1   #因为是要往右边走一直取找大于temp的值，所以每次加 1
        li[right] = li[left]   #上一步的right指定在了为空的位置，直接替换掉
    li[left] = temp  #当所有循环结束后，证明left = right ,他们指向一个位置，用谁都可以
    return left  #temp所在的位置，将列表分为两部分的位置


#递归进行细分
def quick_sort(li, left ,right):
    if left < right:  #分成的小组中至少有两个元素,当left=right时停止递归
        mid = partition(li, left, right)  #第一次调用得到第一个值应该在的位置，将列表分为两部分
        quick_sort(li, left, mid-1)  #对于右边的部分做的操作，对应right的while
        quick_sort(li, mid+1, right)  #对于左边的部分做的操作，对应left的while


li = [43,25,21,64,23,65,76,87,5,3,1,4,8,2,7,9,6]
quick_sort(li,0,len(li)-1)
print(li)
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 23, 25, 43, 64, 65, 76, 87]