python 常见排序算法

python 常见排序算法

冒泡排序

def maopao_sort(list1: list):
    """
    冒泡排序
    复杂度O(N^2)
    :param list1: 每次对相邻两个数进行排
    :return:
    """
    n = len(list1)
    if n < 2:
        return list1
    for i in range(n):
        for j in range(i + 1, n):
            if list1[i] > list1[j]:
                list1[i], list1[j] = list1[j], list1[i]
    return list1

选择排序

def xuanze_sort(list1: list):
    """
    选择排序：每次选择最小的往前排
    复杂度O(N^2)
    :param list1:
    :return:
    """
    n = len(list1)
    if n < 2:
        return list1
    for i in range(n):
        min_index = i
        for j in range(i + 1, n):
            min_index = j if list1[min_index] > list1[j] else min_index
        list1[i], list1[min_index] = list1[min_index], list1[i]
    return list1

插入排序

def charu_sort(list1:list):
    """
    插入排序   前n个数已经排好了，将第n+1个数排进前n个已排好的数中
    复杂度和数据状况有关最差情况：复杂度O(N^2)
    :param list1:
    :return:
    """
    n = len(list1)
    for i in range(1, n):
        value = list1[i]
        j = i-1
        while j >= 0 and value < list1[j]:
            list1[j+1] = list1[j]
            j -= 1
        list1[j+1] = value

    return list1

归并排序

def merge_sort(alist):
    if len(alist) < 2:
        return alist

    num = len(alist) >> 1
    l = merge_sort(alist[:num])
    r = merge_sort(alist[num:])

    return merge(l, r)


def merge(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

快速排序

def kuaisu_sort(arr):
    if len(arr) <= 1:
        return arr
    kuaisu_sort_help(arr, 0, len(arr) - 1)


def kuaisu_sort_help( arr, l, r):
    if l < r:
        less, more = partition(arr, l, r)
        kuaisu_sort_help(arr, l, less - 1)
        kuaisu_sort_help(arr, more + 1, r)


def partition( arr, l, r):
    less = l - 1
    more = r
    index = l
    while index < more:
        if arr[index] < arr[r]:
            less += 1
            swap(arr, index, less)
            index += 1
        elif arr[index] > arr[r]:
            more -= 1
            swap(arr, index, more)
        else:
            index += 1
    swap(arr, more, r)
    return less + 1, more

def swap( arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

if __name__ == '__main__':
    arr = [1, 2, 89, 10,3, 4, 3, 3, 3, 1]
    kuaisu_sort(arr)
    print(arr)

堆排序

def heap_sort( arr):
    heapsize = len(arr)
    if heapsize <= 1: return arr
    for index in range(heapsize):
        heap_insert(arr, index)
    heapsize -= 1
    swap(arr, 0, heapsize)
    while heapsize > 1:
        heapify(arr, 0, heapsize)
        heapsize -= 1
        swap(arr, 0, heapsize)


def heap_insert( arr, index):
    """
    构建一个大根堆
    :param arr:
    :param index:
    :return:
    """
    root_index = (index - 1) >> 1
    while index > 0 and arr[index] > arr[root_index]:
        swap(arr, index, root_index)
        index = root_index
        root_index = (index - 1) >> 1


def heapify( arr, index, heapsize):
    left = (index << 1) + 1
    while left < heapsize:
        big = left + 1 if left + 1 < heapsize and arr[left + 1] > arr[left] else left
        big = big if arr[big] > arr[index] else index
        if big == index:
            break
        swap(arr, index, big)
        index = big
        left = (index << 1) + 1

def swap( arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

if __name__ == '__main__':
    arr = [1, 2, 89, 10,3, 4, 3, 3, 3, 1]
    heap_sort(arr)

    print(arr)