排序 二分查找 冒泡排序 选择排序 插入排序 希尔排序 快速排序

二分查找

一定是基于有序集合的查找

def find(alist,item):
    find = False
    first = 0
    mid_index = 0
    last = len(alist)-1
    
    while first <= last:
        mid_index = (last + first)//2
        if alist[mid_index] < item:
            # 查找元素比中间元素大，去右侧查找
            first = mid_index + 1
        elif alist[mid_index] > item:
            last = mid_index - 1
        else:
            find = True
            break
    return find
        

alist = [1,3,4,5,7,9,10]
print(find(alist,6))

冒泡排序

思想：将序列中的数两两进行比较，依次交换位置，循环得出有序序列

def sort(alist):
    for j in range(len(alist)-1):
        for i in range(len(alist)-j-1):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]  
    return alist

alist = [3,6,5,8,4]
print(sort(alist))

选择排序

思想：先假定一个最大值元素的下标为0，将该元素与其他元素进行比较，如果小于，则将下标替换为对应元素的下标，最后可以得出最大元素的真实下标，将其与最后一个元素进行交换，第二次则继续上述循环，得出第二大元素的下标，与倒数第二个元素进行交换，依次循环n次，直到得出有序序列

def sort(alist):
    for j in range(0,len(alist)-1):
        max_index = 0  # 最大值的下标
        for i in range(1,len(alist)-j):
            if alist[max_index] < alist[i]:
                max_index = i
        alist[len(alist)-1-j],alist[max_index] = alist[max_index],alist[len(alist)-j-1]
    return alist

alist = [3,6,5,8,4]
print(sort(alist))

插入排序

思想：将一个序列分成两个子集（并不是拆分，只是看成两个子集，左侧为有序子集，右侧为无序子集），先取原序列的第一个数作为有序子集，后面的元素作为乱序子集，从乱序子集中取出一个元素，将其与有序子集的最后一个元素进行比较，如果大于则放在有序子集最后一个元素的右侧，如果小于，则先与最后一个严肃交换位置，然后再与前一位元素进行比较，以此循环，直到成功插入，再逐步将乱序子集中的元素循环上述步骤，插入有序列表，循环len（alist）-1 次即可

def sort(alist):
# 有序子集中元素的个数，还可以表示下标
    for i in range(1,len(alist)):
        while i > 0:
            # alist[i] 乱序列表中的第一个元素
            # alist[i-1] 有序列表中的第一个元素
            if alist[i] < alist[i-1]:
                # 乱序子集这种的第一个值小于有序子集的最后一个元素
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
    return alist


alist = [3,4,8,6,2]
print(sort(alist))

希尔排序

gap：增量的值 最后拆分出来的组数

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

思想：首先要得出gap（gap = len（alist）// 2），一共可以主观分成gap组，分别对每组进行插入排序，然后再得到gap（gap = gap//2）,分组进行插入排序，直到gap = 1 时，进行最后一次全组插入排序，就可以得到有序序列

def sort(alist):
    gap = len(alist)//2
# 有序子集中元素的个数，还可以表示下标
    while gap >= 1:
        for i in range(gap,len(alist)):
            while i > 0:
                # alist[i] 乱序列表中的第一个元素
                # alist[i-1] 有序列表中的第一个元素
                if alist[i] < alist[i-gap]:
                    # 乱序子集这种的第一个值小于有序子集的最后一个元素
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= gap
                else:
                    break
        gap = gap // 2
    return alist


alist = [3,4,8,6,2]
print(sort(alist))

快速排序

指定一个基数（乱序中的第一个数据值）

将比基数小的数据放置在基数的左侧，比基数大的数据放置在基数的右侧

思想：将列表中的第一个元素设定为基准数字，赋值给mid变量，然后整个将整个列表中比基准小的放在基准的左侧，比基准大的放在基准的右侧，然后将基准数字左右两侧的序列再根据此方法进行排放

​ 定义两个指针，low指向最左侧，high指向最右侧，然后对最右侧指针进行向左移动，法则是，如果指针指向的数值，比基准小，则将指针位置的数字移动到基准数字原始的位置，否则继续移动指针，如果最右侧指针指向的数值移动到基准位置时，开始移动最左侧指针，将其向右移动，如果该指针指向的数值大于基准数值时则将该数值移动到最右侧指针指向的位置，然后停止移动

​ 如果左右侧指针重复，则将基准放入指针重复的位置，则基准左侧为比基准小的数，右侧为比基准大的数

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 -= 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,high - 1)  
    sort(alist,low+1,end)
        
    return alist
        
alist = [6,1,2,7,9,3,4,5,10,8]
print(sort(alist,0,len(alist)-1))