python排序算法的整理

#冒泡排序，主要思想：从第一个元素开始，向尾部开始比较大小换位置
def bubble_sort(alist):
    for j in range(len(alist)-1,0,-1):
        for i in range(j):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[1]

#选择排序，主要思想：第一个数开始和后面比大小，遇到小的就换到第一个，继续和刚刚换数位之后的数比大小，小就再换，直到最后一个数，如何从第二个数开始重复刚刚的过程
def selection_sort(alist):
    for i in range(n-1):
        min_index = i
        for j in range(i + 1,n):
            if alist[j] < alist[min_index]:
                min_index = j
        if min_index != i:
            alist[i],alist[min_index] = alist[min_index],alist[i]

#插入排序，主要思想：从数列后往前进行比较，如果后面的数比前面的数小，就换位置，换到大于前面数为止
def insert_sort(alist):
    for i in range(1,len(alist)):
        for j in range(i,0,-1):
            if alist[j] < alist[j-1]:
                alist[j],alist[j-1] = alist[j-1],alist[j]

#快速排序，主要思想：第一个元素作为基准元素，第二个与最后一个元素与第一个元素比较大小，比第一个大的元素放右边，小的放左边，
# 循环完后两个游标重合的位置就是基准元素在整个数列中的顺序位置，此时基准元素左边的都比它小，右边的都比它大，左边与右边再重复以上操作。
def quick_sort(alist,start,end):
    if start >= end:
    #递归退出的条件
        return
    mid = alist[start]
    #设定起始元素为要寻找位置的基准元素
    low = start
    #low为序列左边的由左向右移动的游标
    high = end
    #high为序列右边由右向左移动的游标
    while low < high:
        #如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
        while low < high and alist[high] >= mid:
            high -= 1
        alist[low] = alist[high]
        #将high指向的元素放到low的位置上
        while low < high and alist[low] < mid:
        #如果low与high未重合，low指向的元素比基准元素小，则low向右移动
            low += 1
        alist[high] = alist[low]
        #将low指向的元素放到high上
        alist[low] = mid
        #退出后，low与high重合，此时所指的位置为基准元素的正确位置
        #将基准元素放到该位置
        quick_sort(alist,start,low-1)
        #对基准元素左边的子序列进行快速排序
        quick_sort(alist,low+1,end)
        #对基准元素右边的子序列进行快速排序

#希尔排序，主要思想：分割列表，gap就是分割后小列表的长度，各个列表对应位置比较大小然后交换。
def shell_sort(alist):
    n = len(alist)
    # 初始步长
    gap = n / 2
    while gap > 0:
        # 按步长进行插入排序
        for i in range(gap, n):
            j = i
            # 插入排序
            while j >= gap and alist[j - gap] > alist[j]:
                alist[j - gap], alist[j] = alist[j], alist[j - gap]
                j -= gap
        # 得到新的步长
        gap = gap / 2

#归并排序，主要思想：将一个数列分解成对应长度n的n个数列，两两一组，比大小，小的在前合并，然后在两两合并，先比较两个数组的第一位，小的在前，再将未排序数列的第一位与已排序的第二位比较，小的在前，比完排序为止；重复之前的操作，直到变成一个数组
def merge_sort(alist):
    if len(alist) <= 1:
        return alist
    # 二分分解
    num = len(alist)/2
    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])
    # 合并
    return merge(left,right)

def merge(left, right):
    #合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组
    #left与right的下标指针
    l, r = 0, 0
    result = []
    while l<len(left) and r<len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result