python排序

1. 冒泡排序 bubble sort

重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来

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

2. 选择排序 selection sort
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

def selectionsort(nums):
    for i in range(len(nums)):
        mins = i
        for j in range(mins+1, len(nums)):
            if nums[j] < nums[mins]:
                nums[j], nums[i] = nums[i], nums[j]
    return nums

3. 插入排序 insertion sort
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

def insertionsort(nums):
    for i in range(1, len(nums)):
        key = nums[i]
        j = i - 1
        while j >= 0 and nums[j] > key:
            nums[j+1] = nums[j]
            j -= 1
        nums[j+1] = key
    return nums

4. 快排 quick sort  link: https://wiki.jikexueyuan.com/project/easy-learn-algorithm/fast-sort.html

def partition(arr, low, high):
    i = low  # 最小元素索引
    pivot = arr[high]
    for j in range(low, high):
        # 当前元素小于或等于 pivot
        if arr[j] <= pivot:
            arr[i], arr[j] = arr[j], arr[i]
            i = i + 1
    arr[i], arr[high] = arr[high], arr[i]
    return i
# 快速排序函数
def quickSort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quickSort(arr, low, pi - 1)
        quickSort(arr, pi + 1, high)

quickSort(x, 0, len(x)-1)

5. 归并排序 merge sort 

https://www.cnblogs.com/pythonbao/p/10800699.html

分治法:

• 分割：递归地把当前序列平均分割成两半。
• 集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

def merge_sort(arr):
    if len(arr) == 1:
        return arr
    #使用二分法将数列分两个
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]
    #使用递归运算
    return merge(merge_sort(left), merge_sort(right))
def merge(left, right):
    """排序合并两个数列"""
    result = []
    #两个数列都有值
    while len(left) > 0 and len(right) > 0:
        #左右两个数列第一个最小放前面
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    # 只有一个数列中还有值，直接添加
    result += left
    result += right
    return result