py八大排序

冒泡排序

# -*- encoding: utf-8 -*-
"""
@File    : demo.py
@Time    : 2021-09-22 21:29
@Author  : XD
@Email   : gudianpai@qq.com
@Software: PyCharm
"""
def bubble_sort(l):
    for i in range(len(l) - 1):
        for j in range(len(l) - i - 1):
            if l[j] > l[j + 1]:
                l[j], l[j+1] = l[j+1], l[j]
    return l

l = [1,5,4,6,99,55]
print(bubble_sort(l))

时间复杂度为O（$n^2$）
具体来说：交换次数为O（$n^2$），对比次数为O（$n^2$）
冒泡排序可以被优化，在某一趟结束之后，有可能没有进行交换。我们可以设置一个标志去检测某一趟有没有进行交换，如果说没有交换，说明排好序了，直接结束。

def bubble_sort(l):
    exchange = True
    n = len(l) - 1
    while exchange and n:
        exchange = False
        for i in range(len(l) - 1):
            for j in range(len(l) - i - 1):
                exchange = True
                if l[j] > l[j + 1]:
                    l[j], l[j+1] = l[j+1], l[j]
        n = n - 1
    return l

l = [1,5,4,6,99,55]
print(bubble_sort(l))

选择排序

选择排序是对冒泡排序的一种改进，保留了其基本的多躺比对思路，每趟都使得当前最大项就位，，但是对排序交换进行了削减，只是记住位置，最后再和最后一项进行交换

# -*- encoding: utf-8 -*-
"""
@File    : demo.py
@Time    : 2021-09-22 21:29
@Author  : XD
@Email   : gudianpai@qq.com
@Software: PyCharm
"""
def bubble_sort(l):
    exchange = True
    n = len(l) - 1
    while exchange and n:
        exchange = False
        for i in range(len(l) - 1):
            index_max = 0
            for j in range(len(l) - i - 1):
                exchange = True
                if l[j] < l[j + 1]:
                    index_max = j + 1
            l[len(l) - i - 1], l[index_max] = l[index_max], l[len(l) - i - 1]
        n = n - 1
    return l

l = [1,5,4,6,99,55]
print(bubble_sort(l))

插入排序

#插入排序:将无序的元素插入到有序的元素序列中，插入后仍然有序
def insertionSort(l):
    for i in range(1, len(l)):
        temp = l[i]
        j = i - 1
        while temp > l[j] and j >= 0:
            l[j + 1] = l[j]
            j = j - 1
        l[j + 1] = temp
    return l
li = [3,4,5,6,1,7,2,8,9]
li = insertionSort(li)
print(li)

时间复杂度为O（$n^2$）

谢尔排序

#插入排序:将无序的元素插入到有序的元素序列中，插入后仍然有序
def insertionSortGap(l, gap):
    for i in range(gap, len(l)):
        temp = l[i]
        j = i - gap
        while temp > l[j] and j >= 0:
            l[j + gap] = l[j]
            j = j - gap
        l[j + gap] = temp
    return l
def shell_sort(l):
    d = len(li) // 2
    while d >= 1:
        insertionSortGap(l, d)
        d  //= 2

import random
li = list(range(10000))
random.shuffle(li)
shell_sort(li)
print(li)

归并排序

def mergesort(seq):
    """归并排序"""
    #递归结束条件
    if len(seq) <= 1:
        return seq
    #分解问题，并递归调用
    mid = len(seq) // 2  # 将列表分成更小的两个列表
    # 分别对左右两个列表进行处理，分别返回两个排序好的列表
    left = mergesort(seq[:mid])
    right = mergesort(seq[mid:])
    # 对排序好的两个列表合并，产生一个新的排序好的列表
    return merge(left, right)

def merge(left, right):
    """合并两个已排序好的列表，产生一个新的已排序好的列表"""
    result = []  # 新的已排序好的列表
    i = 0  # 下标
    j = 0
    # 对两个列表中的元素 两两对比。
    # 将最小的元素，放到result中，并对当前列表下标加1
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result


seq = list(range(10000))
import random
random.shuffle(seq)
print('排序前：',seq)
result = mergesort(seq)
print('排序后：',result)

快速排序

def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp: #从右边找比tmp小的数
            right -= 1#往左走一位
        li[left] = li[right]#把右边的值写道左边的空位上
        while left < right and li[left] <= tmp:
            left += 1
        li[right] = li[left]
    li[left] = tmp#将tmp归位
    return left
def quick_sort(li, left, right):
    if left < right:#至少两个元素
        mid = partition(li, left, right)
        quick_sort(li, left, mid - 1)
        quick_sort(li, mid + 1, right)
li = [5,7,4,6,3,1,2,9,8]
partition(li, 0, len(li) - 1)
print(li)
quick_sort(li,0, len(li) - 1)
print(li)

堆排序

基数排序