冒泡算法||| 选择排序 ||希尔排序 || 快速排序

冒泡算法

#列表元素两辆比较，大的值逐渐向后移动
# def sort(alist):
#     for i in range(len(alist)-1):
#         if alist[i]>alist[i+1]:
#             alist[i],alist[i+1]=alist[i+1],alist[i]
#     return alist
#
# alist=[1,3,5,2,6,9,8,7]
# print(sort(alist))

# [1, 3, 2, 5, 6, 8, 7, 9]

#逐渐将乱序序列的最大值找出放置在乱序序列的尾部
# def sort(alist):
#     for j in range(len(alist)-1):
#         for i in range(len(alist)-1-j):
#             if alist[i]>alist[i+1]:
#                 alist[i],alist[i+1]=alist[i+1],alist[i]
#     return alist
#
# alist=[1,3,5,2,6,9,8,7]
# print(sort(alist))

# [1, 2, 3, 5, 6, 7, 8, 9]

选择排序

#建乱序中的最大值找出，跟最后一个元素交换位置
# def sort(alist):
#     max_index=0 #最大值下标
#     for  i in range(1,len(alist)):
#         if alist[max_index]<alist[i]:
#             max_index=i
#     alist[len(alist)-1],alist[max_index]=alist[max_index],alist[len(alist)-1]
#     return alist
# alist=[3,8,5,7,6]
# print(sort(alist))

希尔排序

gap
- 增量值
- 拆分出来的组数

插入排序就是增量为1的希尔排序

# def sort(alist):
#     gap=len(alist)//2 #初识gap
#     for i in range(gap,len(alist)):
#         while i>0:
#             if alist[i]<alist[i-gap]:
#                 alist[i],alist[i-gap]=alist[i-gap],alist[i]
#                 i-=gap
#             else:
#                 break
#     return alist
# alist=[3,8,5,2,7,6]
# print(sort(alist))

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


def sort(alist):
    gap=len(alist)//2 #初识gap
    while gap>=1:
        for i in range(gap,len(alist)):
            while i>0:
                if alist[i]<alist[i-gap]:
                    alist[i],alist[i-gap]=alist[i-gap],alist[i]
                    i-=gap
                else:
                    break
        gap//=2
    return alist
alist=[3,8,5,2,7,6]
print(sort(alist))

快速排序

1.指定一个基数(乱序中的第一个数据值)
2.将比基数小的数据放置在基数的左侧，比基数大的数放在基数的右侧
从右开始偏移high
将列表中第一个元素设定为基准数字，赋值给mid变量，然后将整个列表中比基准小的数值放在基准的左侧，比基准到的数字放在基准右侧。然后将基准
数字左右两侧的序列在根据此方法进行排放。
定义两个指针，low指向最左侧，high指向最右侧
然后对最右侧指针进行向左移动，移动法则是，如果指针指向的数值比基准小，则将指针指向的数字移动到基准数字原始的位置，否则继续移动指针。
如果最右侧指针指向的数值移动到基准位置时，开始移动最左侧指针，将其向右移动，如果该指针指向的数值大于基准则将该数值移动到最右侧指针指向的位置，然后停止移动。
如果左右侧指针重复则，将基准放入左右指针重复的位置，则基准左侧为比其小的数值，右侧为比其大的数值。

# def sort(alist):
#     #基数
#     mid=alist[0]
#     low=0
#     high=len(alist)-1
#
#     while low<high:
#         #偏移high
#         while low<high:
#             if alist[high]>mid:
#                 #向左侧偏移high
#                 high-=1
#             else:
#                 alist[low]=alist[high]
#                 break
#
#         #偏移low
#         while low<high:
#             if alist[low]<mid:
#                 low+=1
#             else:
#                 alist[high]=alist[low]
#                 break
#         if low==high:
#             alist[low]=mid
#             break
#     return alist
#
# alist=[6,1,2,7,9,3,4,5,10,8]
#
# print(sort(alist))

# [5, 1, 2, 4, 3, 6, 9, 7, 10, 8]



def sort(alist,start,end):
    #基数

    low=start
    high=end
    if low>high:
        return
    mid = alist[start]
    while low<high:
        #偏移high
        while low<high:
            if alist[high]>mid:
                #向左侧偏移high
                high-=1
            else:
                alist[low]=alist[high]
                break

        #偏移low
        while low<high:
            if alist[low]<mid:
                low+=1
            else:
                alist[high]=alist[low]
                break
        if low==high:
            alist[low]=mid
            break
    #作用到左侧
    sort(alist,start,low-1)
    #作用到右侧
    sort(alist,high+1,end)
    return alist

alist=[6,1,2,7,9,3,4,5,10,8]

print(sort(alist,0,len(alist)-1))

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]