排序算法--冒泡排序、选择排序、归并排序、快速排序、堆排序、计数排序

冒泡排序

最简单的排序，原理非常简单，只要当前数比后面的数大，就把当前数往后移，直到数组末尾。

def bubble_sort(arr):

    if len(arr) < 2:
        return arr

    j = len(arr) - 1
    while j > 0:
        for i in range(j):
            if arr[i] > arr[i + 1]:
                arr[i], arr[i + 1] = arr[i + 1], arr[i]
        j -= 1

    return arr

选择排序

假设当前数是最小的数，找到之后最小的数，并将当前数和找到的最小的数互换，相对于先找最小，在慢慢往后找。

# 选择排序
def selectionSort(arr):

    if len(arr) < 2:
        return arr

    for i in range(len(arr) - 1):
        min_index = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]

    return arr

插入排序

假设当前数及之前已经排好序，判断下一个数应该插入到之前排好序的中间那个位置，相对于从已经排好序的区间尾部开始判断，依次交换顺序，直到满足排序顺序。

# 插入排序
def insert_sort(arr):

    if len(arr) < 2: return arr

    for i in range(len(arr) - 1):
        j = i + 1
        while j > 0 and arr[j] < arr[j - 1]:
            arr[j], arr[j - 1] = arr[j - 1], arr[j]
            j -= 1

    return arr

归并排序

基本思想是，利用递归，将每个递归后排序完成的小区间合并，最终形成完整的排序

# 归并排序
def merge_sort(arr):

    if len(arr) < 2: return arr

    def process(arr, left, right):

        if left == right: return

        mid = left + (right - left) >> 1
        process(arr, left, mid)
        process(arr, mid + 1, right)

        tmp = []
        p1, p2 = left, mid + 1
        while p1 <= mid and p2 <= right:
            if arr[p1] < arr[p2]:
                tmp.extend(arr[p1])
                p1 += 1
            else:
                tmp.extend(arr[p2])
                p2 += 1

        while p1 <= mid:
            tmp.extend(arr[p1])
            p1 += 1

        while p2 <= right:
            tmp.extend(arr[p2])
            p2 += 1

        arr[left:right + 1] = tmp
        return arr

    return process(arr, 0, len(arr) - 1)

快速排序

基本思想是，按照某个值将数组划分，大于它的放右边，小于它的放左边，等于在中间。
递归划分每个区间，直到当前区间只有一个数，划分值选取当前区间的最后一个值。

# 快速排序
def quick_sort(arr, left, right):

    def partition(arr, left, right):
        # left, right = -1, len(arr)
        index = left
        left -= 1
        tmp = arr[right]

        while index <= right:
            if arr[index] > tmp:
                arr[index], arr[right] = arr[right], arr[index]
                right -= 1
            elif arr[index] < tmp:
                arr[index], arr[left + 1] = arr[left + 1], arr[index]
                left += 1
                index += 1
            else:
                index += 1
        # arr[-1], arr[right] = arr[right], arr[-1]

        return [left + 1, right] # 返回等于的区间位置

    if left < right:

        tmp = partition(arr, left, right)
        quick_sort(arr, left, tmp[0] - 1)
        quick_sort(arr, tmp[1] + 1, right)

    return arr

堆排序

首先将数组中的所有数建立成一个大跟堆，大跟堆的结构类似于完全二叉树，而且每个子树的中最大值都是根节点的值，而当前节点的根节点在数组中位置为 （i- 1）/ 2，所以只要判断新进的数是否比根节点的数大，大就交换位置，否则不换。依次从头到尾建立大跟堆结构。
建立好大跟堆结构后，数组中第一个数必然是最大的数，将它和数组中最后一个数交换，等于是从尾部开始排序，先找到最大的放末尾。但交换之后，一定不满足大跟堆结构，所以需要重新调整结构。调整结束后再次交换，不断重复。直到大跟堆的大小为0.
调整结构中，由于是从上开始调整，因此需要判断当前值和它的左右节点中，哪个最大就和谁交换位置，左节点的位置为 2*i + 1， 如果最大值是自己，则交换调整结束。
每一次调整之前，都要注意当前还需要调整的范围，因为数组的后面在之前操作中已经排好序，所以要注意边界。

# 堆排序
def heap_sort(arr):

    if len(arr) < 2: return arr

    for i in range(len(arr)):
        heapInsert(arr, i)

    arr[0], arr[-1] = arr[-1], arr[0]
    heap_size = len(arr) - 1 # 需要调整的边界

    while heap_size > 0:
        heapify(arr, heap_size, 0)
        arr[heap_size - 1], arr[0] = arr[0], arr[heap_size - 1]
        heap_size -= 1

    return arr

# 插入新值过程
def heapInsert(arr, index):
    root = (index - 1) >> 1

    while arr[root] < arr[index]:
        arr[root], arr[index] = arr[index], arr[root]
        index = root
        root = (index - 1) >> 1

# 调整过程
def heapify(arr, heap_size, index):

    left = 2 * index + 1 # 左节点

    while left < heap_size:
        largest = left + 1 if left + 1 < heap_size and arr[left + 1] > arr[left] else left
        largest = largest if arr[largest] > arr[index] else index

        if largest == index:
            break

        arr[largest], arr[index] = arr[index], arr[largest]
        index = largest
        left = 2 * index + 1

堆排序是在原数组上操作，因此空间复杂度为O（1），时间复杂度为O（NlogN）

计数排序

根据所给的数组，准备一个辅助数组，辅助数组的大小是待排序数组的中的最大数。遍历待排序数组，将每个数出现的次数记录在辅助数组相应的位置上，比如说4出现了3次，就在辅助数组4的位置上记3，没有出现过就是0.遍历结束后，按照辅助数组中的值恢复即可。
虽然计数排序很简单，速度也很快。时间复杂度为O（N），但实际运用的不多，因为它不能用于带小数的、或者为负数的，而且空间复杂度依赖于数据状况，因此缺陷也很大。

各种排序的时间复杂度和空间复杂度

冒泡排序,选择排序,堆排序,插入排序,的空间复杂度为O(1)
快速排序空间复杂度为logn(因为递归调用了) ,
归并排序空间复杂是O(n),需要一个大小为n的临时数组