排序算法

类型	最坏情况	时间复杂度	空间复杂	最好情况	稳定性
顺序查找	n	O(n)
需找最大项或最小项	n-1	O(n-1)
二分查找法	log2n	O(log2n)
冒泡排序法	n^2	O(n^2)	O(1)	O(n)	稳定
快速排序法	n^2	O(nlogn)	O(logn)	O(nlogn)	不稳定
简单插入排序法	n^2	O(n^2)	O(1)	O(n)	稳 定
希尔排序法	n^r(1<r<2)	O(n^1.5))	O(1)	O(nlog2n)	不稳定
简单选择排序法	n^2	O(n^2)	O(1)	O(n^2)	不稳定
堆排序	nlog2n	O(nlog2n)	O(1)	O(nlog2n)	不稳定
归并排序	nlog2n	O(nlog2n)	O(n)	O(nlog2n)	稳定

堆排序，记录数较多的情况下适用~
冒泡排序算法

def bubble_sort(list_1):
    # 冒泡排序
    list_length = len(list_1)
    for i in range(list_length):
        the_element = list_1[i]
        for j in range(i + 1, list_length):
            if the_element > list_1[j]:
                list_1[i] = list_1[j]
                list_1[j] = the_element
    return list_1

插入排序：

def insert_sort(list_1):
    # 插入排序
    list_length = len(list_1)
    for i in range(1, list_length):
        # 关键是每次都从要排序的元素的前一个元素开始比较
        j = i - 1
        the_element = list_1[i]
        while j >= 0:
            if list_1[j] > the_element:
                list_1[j + 1] = list_1[j]
                list_1[j] = the_element
            j -= 1
    return list_1

希尔排序

def shell_sort(list_1):
    # 希尔排序
    list_length = len(list_1)
    step = 2
    group = list_length / step
    while group > 0:
        for i in range(group):
            j = i + group
            while j < list_length:
                # 在每组中用插入排序
                k = j - group
                the_element = list_1[j]
                while k > 0:
                    if list_1[k] > the_element:
                        list_1[k + group] = list_1[k]
                        list_1[k] = the_element
                    k -= group
                j += group
        group /= step
    return list_1

选择排序

def select_sort(list_1):
    # 选择排序
    list_length = len(list_1)
    for i in range(list_length):
        min_index = i
        for j in range(i + 1, list_length):
            # 找寻后面部分最小的元素与之交换
            if list_1[j] < list_1[min_index]:
                min_index = j
        list_1[i], list_1[min_index] = list_1[min_index], list_1[i]
    return list_1

快速排序算法思想
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，保存在key中，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，用A[j]覆盖A[0],
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，用A[i]覆盖A[j] 即每一次覆盖上一次的
5）重复第3、4步，直到i=j；找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束。
6) 将K还原
7) 第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。

def quick_sort(list, low, high):
    """
    控制快速排序递归的主函数
    :param list:用户传入的待排序列表
    :param low:列表左下标
    :param high:列表右下标
    """
 
    if low < high:
        k_index = deal_list(list, low, high)
 
        # 递归分界值左边的一组
        quick_sort(list, low, k_index - 1)
        # 递归分界值右边的一组
        quick_sort(list, k_index + 1, high)
 
 
def deal_list(list, low, high):
    """实现每趟排序,并找出分界值的下标k_index"""
 
    # 必须把low ,high保存起来,上面的主函数的left right始终不变
    left = low
    right = high
 
    # 将列表最左边的值赋值给k
    k = list[low]
 
    while left < right:  # 当左右"指针"未碰头时就一直比较移动下去
        # 从右边开始,如果比K大:right左移一位,继续比较
        while list[right] > k:
            right -= 1
 
        # 从左边开始,如果比K小: left右移一位,继续比较
        while list[left] <= k:
            left += 1
 
        # 若移动完，二者仍未相遇则交换下标对应的值
        if left < right:
            list[right], list[left] = list[left], list[right]
 
    # 若移动完，已经相遇，则交换right对应的值和k
    list[low] = list[right]
    list[right] = k
    return right
 
if __name__ == '__main__':
 
    list = [6, 1, 2, 7, 9, 3, 4, 5, 10, 8]
    quick_sort(list, 0, len(list) - 1)
    print(list)

输入 6,1,2,7,9,3,4,5,10,8
首先右边指针向前，直到找到小于6的就停止，左边指针向后，直到找到大于6的就停止，交换：6,1,2,5,9,3,4,7,10,8
6,1,2,5,4,3,9,7,10,8
3,1,2,5,4,6,9,7,10,8
至此，6左边的都比6小，6右边的都比6大