十大排序方法 Python实现

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
冒泡排序	O(n²)	O(n)	O(n²)	O(1)	In-place	稳定
选择排序	O(n²)	O(n²)	O(n²)	O(1)	In-place	不稳定
插入排序	O(n²)	O(n)	O(n²)	O(1)	In-place	稳定
希尔排序	O(n log n)	O(n log² n)	O(n log² n)	O(1)	In-place	不稳定
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)	Out-place	稳定
快速排序	O(n log n)	O(n log n)	O(n²)	O(log n)	In-place	不稳定
堆排序	O(n log n)	O(n log n)	O(n log n)	O(1)	In-place	不稳定
计数排序	O(n + k)	O(n + k)	O( n + k)	O(k)	Out-place	稳定
桶排序	O(n + k)	O(n + k)	O(n²)	O( n + k)	Out-place	稳定
基数排序	O( n * k)	O( n * k)	O( n * k)	O( n + k)	Out-place	稳定

1.冒泡排序

'''
bubble sort 原理
从左到右两个进行比较，把如果是反序就重新排列，每进行一遍，就会有一个最大数(最小数)浮出到未排好的末端
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成
'''
import random, time


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


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(bubble_sort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

2.插入排序

'''
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中，找到相应位置并插入。
'''
import random, time


def insert_sort(list):
    for i in range(len(list)):
        for j in range(i):
            if list[i] < list[j]:
                list.insert(j, list.pop(i))
    return list


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(insert_sort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

3.选择排序

'''
选择排序(Selection-sort)工作原理：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
然后，再从剩余未排序元素中继续寻找最小
（大）元素，然后放到已排序序列的末尾
'''
import time, random


def select_sort(list):
    for i in range(len(list)):
        min = i
        for j in range(i, len(list)):
            if list[min] > list[j]:
                min = j
        list[min], list[i] = list[i], list[min]
    return list


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(select_sort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

4.堆排序

'''
堆排序原理：
通过构建大顶堆，最大的数字在最上面
然后将最顶的数字与最后的数字交换，最大的数字将在最后
出去最后的数字，将顶部元素再堆化，保证最大的再顶部，重复以上操作即可
'''
import time, random


def heapify(arr, i, arrLen):	# 堆化
    left = 2 * i + 1
    right = 2 * i + 2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, largest, arrLen)


def heapSort(arr):
    arrLen = len(arr)
    for i in range(len(arr) // 2 - 1, -1, -1):
        heapify(arr, i, arrLen)
    for i in range(1, arrLen):
        arrLen -= 1
        arr[arrLen], arr[0] = arr[0], arr[arrLen]
        heapify(arr, 0, arrLen)
    return arr


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(heapSort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

5.归并排序

'''
归并排序原理：
归并排序是一种分而治之的排序方法，
将所有数字分成两部分，再讲每部分分成两部分，直到最后剩余一个，
然后再合并，从小到大依次合并
'''
import time, random


def mergeSort(arr):
    if (len(arr) < 2):
        return arr
    middle = len(arr) // 2
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))

def merge(left, right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    if left:
        result.extend(left)
    if right:
        result.extend(right)
    return result


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(mergeSort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

6.快速排序

'''
快速排序原理：
选择一个数，将所有数分成两部分，左边的比它小，右边的比它大
然后左边的数字中再选择一个数，将左边的 数再分成两部分，左边的比它小，右边的比它大
右边也是如此
一直重复，直到排好序
'''
import random, time


def quick_sort(array):
    def recursive(begin, end):
        l, r = begin, end
        if l < r:
            pivot = array[l]
            while l < r:
                while l < r and array[r] >= pivot:
                    r -= 1
                while l < r and array[l] <= pivot:
                    l += 1
                array[r], array[l] = array[l], array[r]
            array[l], array[begin] = pivot, array[l]
            recursive(begin, l - 1)
            recursive(r + 1, end)
        return

    recursive(0, len(array) - 1)
    return array


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 100) for i in range(100)]
    # print(Li)
    print(quick_sort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

7.希尔排序

import time, random


def Shell_sort(L):
    step = len(L) // 2
    while step > 0:
        for i in range(step, len(L)):  # 在索引为step到len（L）上，比较L[i]和L[i-step]的大小
            while i >= step and L[i] < L[i - step]:  # 这里可以调整step从小到大或者从大到小排列
                L[i], L[i - step] = L[i - step], L[i]
                i -= step
        step //= 2
    return L


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(Shell_sort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

8.计数排序

'''
计数排序的基本思想是：对每一个输入的元素a[i]，
确定小于 a[i] 的元素个数。所以可以直接把 a[i]
放到它输出数组中的位置上。假设有5个数小于 a[i]
所以 a[i] 应该放在数组的第6个位置上。
'''
import random, time


def counting_sort(arr):
    k = max(arr)
    n = len(arr)
    b = [0 for i in range(n)]
    c = [0 for i in range(k + 1)]
    for i in arr:
        c[i] += 1
    for i in range(k):
        c[i + 1] += c[i]
    for i in arr:
        b[c[i] - 1] = i
        c[i] -= 1
    return b


if __name__ == "__main__":
    start = time.time()
    ll = [random.randint(1, 1000) for i in range(100)]
    # print(ll)
    print(counting_sort(ll))
    end = time.time()
    print('用时{}s'.format(end - start))

9.桶排序

import time, random


def bucket_sort(lst):
    pre_lst = [0] * max(lst)  # 预先设定的列表，全部置零
    result = []
    for score in lst:  # 遍历成绩，相应得分位置+1
        pre_lst[score - 1] += 1

    i = 0
    while i < len(pre_lst):  # 遍历生成的列表，从小到大
        j = 0
        while j < pre_lst[i]:
            result.append(i + 1)
            j += 1
        i += 1
    return result


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(bucket_sort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))

10.基数排序

import time, random


def radix_sort(arr):
    d = len(str(max(arr)))
    for i in range(d):  # 从个位到最高位共d轮排序
        m = [[] for i in range(10)]  # 因为每一位数字都是0~9，故建立10个桶
        '''对于数组中的元素，首先按照最低有效数字进行
                   排序，然后由低位向高位进行。'''
        for j in arr:
            m[j // (10 ** i) % 10].append(j)  # 将数按位数放在对应的桶中
            '''对于3个元素的数组[977, 87, 960]，第一轮排序首先按照个位数字相同的
               放在一个桶s[7]=[977],s[7]=[977,87],s[0]=[960]
               执行后list=[960,977,87].第二轮按照十位数，s[6]=[960],s[7]=[977]
               s[8]=[87],执行后list=[960,977,87].第三轮按照百位，s[9]=[960]
               s[9]=[960,977],s[0]=87,执行后list=[87,960,977],结束。'''
        arr = [item for l in m for item in l]  # 将桶中数据合并起来
    return arr


if __name__ == '__main__':
    start = time.time()
    Li = [random.randint(1, 1000) for i in range(100)]
    # print(Li)
    print(radix_sort(Li))
    end = time.time()
    print('用时{}s'.format(end - start))