排序算法（下）

'''
希尔排序:gap步长的概念,根据gap把alist分成多个部分,子list,分别进行插入排序过程
即alist=[1,2,3,4,5,6,7,8,9,10]  gap=4
分成 (1)1,5,9  (2)2,6,10  (3)3,7  (4)4,8    分别插入排序


def shell_sort(alist):
    n = len(alsit)
    gap = n // 2 步长初始取值 取整数
    
    while gap > 0:
        # 内部逻辑和插入排序相同,只是索引变化是根据gap
        # 遍历出所有的子list
        for j in range(gap,n):
            i = j 
            # 控制1个子list的插入排序过程,把1变成gap,这时候gap就是当前索引值
            # 1个子list = [ 20, 97 ] 执行插入排序   alist[i] = 97   alist[i-gap] = 20
            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
        
例子: alist = [ 20 , 55 , 12 , 66 , 33 , 97 , 84 , 23 , 81 , 43 , 29 ]   n = 10   gap = 5
        index   0    1    2    3    4    5    6    7    8    9    10


'''


'''
快速排序:以索引0的值作为标准值,在alist两端同时比较,左端是low点,右端是high点,如果发生左端low点大于标准值,右端high点小于标准值,
那么互换位置,最终能找到标准值所在的索引,并且左端都小于标准值,右端高于标准值,接下来分别对左右两端快排,以索引为0和索引为确定位置+1作为新的标准值
def quick_sort(alist):
    n = len(alist)
    mid_value = alist[0]  标准值,已经用变量记录了,所以接下来的重新赋值没问题
    low = 0
    high = n - 1 
    
    while low < high:
        # high点左移
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low] = alist[high]
        while low < high and alist[low] < mid_value:
            low += 1
        alist[high] = alist[low]
    # 当low等于high时说明重合,到达了标准值的准确位置
    alist[low] = mid_value
    
    # 当确定一个标准值的准确位置后,标准值两侧的内容继续进行快排,函数的递归,但是右侧就不是从索引为0的位置开始了,需要传参,需要控制递归停止
    # 左侧快排
    quick_sort(alist,first,low-1)  为了通用这时候仍然传入alist但是我指定开始和结束位置
    # 右侧快排
    quick_sort(alist,low+1,last)
    
    # 改写
    def quick_sort(alist,first,last):  列表长度n传参传入 
        mid_value = alist[first]
        low = first
        high = last
        # 递归停止
        if first >= last:
            return
'''


'''
归并排序:把完整alist拆分成以每个元素为单位的小list,然后合并
def merge_sort(alist):
    n = len(alist)
    # 取中间的索引值,以它来分割列表直到最终列表只有一个元素
    mid = n // 2
    # 下边函数的递归终止条件,小list长度为1只有一个元素
    if n == 1   
        return alist    返回最终列表,分别作为左右侧列表接收
    left_list = merge_sort(alist[:mid])    
    right_list = merge_sort(alist[mid:])    直到有n==1的返回值才开始进行下一行代码
    
    # 开始合并,第一次合并的是最小列表,即小list中只有1个元素
    left,right = 0,0
    sorted_list= []
    
    left_n = len(left_list)
    right_n = len(right_list)
    
    while left < left_n and right < right_n:
        if left_list[left] < right_list[right]:
            sorted_list.append(left_list[left])
            left += 1
        else:
            sorted_list.append(right_list[right])
            right += 1
    
    sorted_list += left_list[left:]  避免末尾还有没添加的
    sorted_list += right_list[right:]


    return sorted_list  返回给上边的递归函数,把合并后的有序的返回继续合并


'''