python快速排序最简单写法_简单几种排序(python实现)

1. 插入排序

从索引1元素a开始,依次和前面比较(从后往前),当该元素a小于已经排序好元素b,那么b向后移一位.最后肯定留一个"坑",把a塞进去.

代码:

def insertions_sort(array):
    n = len(array)
    for i in range(1,n):
        tmp = array[i]
        j = i - 1
        while j >= 0 and array[j] > tmp:
            array[j+1] = array[j]
            j -= 1
        array[j+1] = tmp
    return array

2. 冒泡排序

一句话,让大的数沉底

两两比较,让大的数放在数组末端

代码:

def bubbleSort(array):
    n = len(array)
    f = n-1
    for _ in range(n-1):
        for i in range(f):
            if array[i+1] < array[i]:
                array[i],array[i+1] = array[i+1],array[i]
        f -= 1
    return array

3. 选择排序

最简单最直观,最符合人的思路的,就是遍历数组,每次都把最小的放到相应位置

举个例子:

[2,1,3]-> [1,2,3]

代码:

def select_sort(array):
    n = len(array)
    for i in range(n):
        for j in range(i, n):
            if array[j] < array[i]:
                array[i], array[j] = array[j], array[i]
    return array

4. 快速排序

一句话:找一个哨兵,把小于这个哨兵的数放在左边,把大于这个哨兵的数放在右边,然后依次递归左边,右边;

代码:

def quick_sort(array):
    n = len(array)
    def helper(array,left,right):
        if left >= right:
            return array
        base = array[left]
        ln = left
        rn = right
        while left < right:
            while left < right and array[right] >= base:
                right -= 1
            while left < right and array[left] <= base:
                left += 1
            array[left],array[right] = array[right],array[left]
        array[left],array[ln] = array[ln],array[left]
        helper(array,ln,left-1)
        helper(array,right+1,rn)
        return array
    return helper(array,0,n-1)

5. 归并排序

分而治之

代码:

def merge_sort(array):
    n = len(array)
    if n <=1:
        return array
    mid = n // 2
    left = merge_sort(array[:mid])
    right = merge_sort(array[mid:])
    return merge(left, right)


def merge(left, right):
    res = []
    i = 0
    j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1
    res += left[i:]
    res += right[j:]
    return res

6. 堆排序

代码:

def adjust_heap(array, i, n):
    lchild = 2 * i + 1
    rchild = 2 * i + 2
    max_loc = i
    if i < n /2:
        if lchild < n and array[lchild] > array[max_loc]:
            max_loc = lchild
        if rchild < n and array[rchild] > array[max_loc]:
            max_loc = rchild
        if max_loc != i:
            array[max_loc],array[i] = array[i],array[max_loc]
            adjust_heap(array,max_loc,n)
def build_heap(array, n):
    for i in range(n // 2, -1, -1):
        adjust_heap(array, i, n)
        print(array)
def heap_sort(array):
    n = len(array)
    build_heap(array, n)
    for i in range(n-1,-1,-1):
        array[i],array[0] = array[0],array[i]
        adjust_heap(array,0,i)
    return array