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

冒泡算法

#列表元素两辆比较，大的值逐渐向后移动
# 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]