十大排序算法-Python实现

十大排序算法

1、选择排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 01-选择排序.py
@time: 2023/8/4 9:12
@desc: 
"""

import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


@func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """
    print(arr)
    if len(arr) <= 1:
        return arr
    n = len(arr)
    for i in range(len(arr)):
        minindex = i
        for j in range(i + 1, n):
            if arr[j] < arr[minindex]:
                minindex = j
        arr[minindex], arr[i] = arr[i], arr[minindex]

    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(1000)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

2、插入排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 02-插入排序.py
@time: 2023/8/4 13:13
@desc: 
"""
import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


@func_time
def main(arr: list):
    n = len(arr)
    if n <= 1:
        return arr

    for i in range(1, n):
        for j in range(i, 0, -1):
            if arr[j] < arr[j - 1]:
                arr[j], arr[j - 1] = arr[j - 1], arr[j]
    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(1000)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

3、冒牌排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 03-冒泡排序.py
@time: 2023/8/4 13:21
@desc: 
"""

import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


@func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """
    print(arr)
    if len(arr) <= 1:
        return arr
    n = len(arr)

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

    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

4、希尔排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 04-希尔排序.py
@time: 2023/8/4 13:28
@desc: 
"""

import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer




@func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """
    print(arr)
    if len(arr) <= 1:
        return arr
    n = len(arr)

    num = n // 2

    while num > 0:
        for i in range(num, n):
            j = i
            while j >= num:
                if arr[j - num] > arr[j]:
                    arr[j], arr[j - num] = arr[j - num], arr[j]
                j -= num
        num = num // 2

    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

5、归并排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 05-归并排序.py
@time: 2023/8/4 15:42
@desc: 
"""

import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


def mergr(leftarr: list, rightarr: list):
    leftIndex, rightIndex, mergeArr = 0, 0, []
    while leftIndex < len(leftarr) and rightIndex < len(rightarr):
        if leftarr[leftIndex] <= rightarr[rightIndex]:
            mergeArr.append(leftarr[leftIndex])
            leftIndex += 1
        else:
            mergeArr.append(rightarr[rightIndex])
            rightIndex += 1
    if leftIndex < len(leftarr):
        mergeArr = mergeArr + leftarr[leftIndex:]
    if rightIndex < len(rightarr):
        mergeArr = mergeArr + rightarr[rightIndex:]

    return mergeArr


def sort(arr: list):
    if len(arr) <= 1:
        return arr
    n = len(arr)

    mid = n // 2
    leftArr = main(arr[:mid])
    rightArr = main(arr[mid:])
    return mergr(leftArr, rightArr)


# @func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """
    arr = sort(arr)
    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

6、快速排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 06-快速排序.py
@time: 2023/8/4 16:00
@desc: 
"""

import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


def partionSort(arr, leftIndex: int, rightIndex: int):
    """

    :param arr: 待排序数组
    :param leftIndex: 左下标
    :param rightIndex: 右下标
    :return:
    """
    i = leftIndex
    j = rightIndex
    pviot = arr[leftIndex]

    while i != j:
        while i < j and arr[j] > pviot:
            j -= 1
        while i < j and arr[i] <= pviot:
            i += 1
        if i < j:
            arr[i], arr[j] = arr[j], arr[i]

    arr[leftIndex], arr[i] = arr[i], arr[leftIndex]
    return i


def quickSort(arr: list, leftIndex: int, rightIndex: int):
    # if len(arr) <= 1:
    #     return arr
    if leftIndex < rightIndex:
        pivot = partionSort(arr, leftIndex, rightIndex)
        quickSort(arr, leftIndex, pivot - 1)
        quickSort(arr, pivot + 1, rightIndex)

    return arr


# @func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """

    arr = quickSort(arr, 0, len(arr) - 1)
    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

7、堆排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 07-堆排序.py
@time: 2023/8/4 16:14
@desc:
"""
import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


def heapify(arr, low: int, hight: int):
    """

    :param arr: 待排序数组
    :param leftIndex: 左下标
    :param rightIndex: 右下标
    :return:
    """
    i = low
    j = low * 2 + 1
    temp = arr[i]

    while j <= hight:
        if j + 1 <= hight and arr[j] < arr[j + 1]:
            j += 1
        if arr[j] > temp:
            arr[i] = arr[j]  # 进行赋值
            i = j
            j = 2 * i + 1
        else:
            break
    arr[i] = temp


def heapSort(arr: list):
    if len(arr) <= 1:
        return arr

    n = len(arr)

    i = n // 2 - 1
    while i > -1:
        heapify(arr, i, n - 1)
        i -= 1

    # 挨个出数据

    for height in range(n - 1, -1, -1):
        arr[0], arr[height] = arr[height], arr[0]
        heapify(arr, 0, height - 1)

    return arr


# @func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """

    arr = heapSort(arr)
    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

8、桶排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 08-桶排序.py
@time: 2023/8/4 17:32
@desc: 
"""

import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


def selectSort(arr: list):
    """

    :param arr:
    :return:
    """
    lenth = len(arr)

    if lenth <= 1:
        return arr
    for i in range(lenth - 1):
        min = 1
        for j in range(i + 1, lenth):
            if arr[min] > arr[j]:
                min = j
        if i != min:
            arr[i], arr[min] = arr[min], arr[i]

    return arr


def selectMax(arr: list):
    """

    :param arr: 待排序列表
    :return:  最大和最小值
    """
    if len(arr) <= 1:
        return 0, 0
    min = arr[0]
    max = arr[1]

    for i in range(len(arr)):
        if arr[i] > arr[0]:
            max = arr[i]
        if arr[i] < arr[0]:
            min = arr[i]

    return min, max


def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """
    if len(arr) <= 1:
        return arr
    n = len(arr)

    min, max = selectMax(arr)
    buckets = [[] for i in range(n+1)]
    for i in range(n):
        index = arr[i] * (n - 1) // max
        buckets[index].append(arr[i])
    # 木桶排序
    res = []
    for i in range(n):
        bucketslen = len(buckets[i])
        if bucketslen > 0:
            buckets[i] = selectSort(buckets[i])
            res.extend(buckets[i])

    return res


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

9、计数排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 09-计数排序.py
@time: 2023/8/4 18:18
@desc: 
"""

import random
import time


def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


@func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """
    print(arr)
    if len(arr) <= 1:
        return arr
    n = len(arr)

    max = arr[0]
    for i in range(n):
        if arr[i] > max:
            max = arr[i]
    # // 构建计数捅
    buckets = [0 for i in range(max + 1)]
    for i in arr:
        buckets[i] += 1
    # // 4. 遍历计数桶取出元素排序
    arrIndex = 0
    for i in range(len(buckets)):
        while buckets[i] > 0 and arrIndex < len(arr):
            arr[arrIndex] = i
            buckets[i] -= 1
            arrIndex += 1
    return arr


if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

10、基数排序：

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
@author: henry_oulen@163.com
@file: 10-基数排序.py
@time: 2023/8/4 19:35
@desc: 
"""
import random
import time


"""
 基数排序(radix sort)属于"分配式排序"(distribution sort)，又称"桶子法"(bucket sort)或bin sort，顾名思义，
 它是透过键值的部份资讯，将要排序的元素分配至某些"桶"中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，
 其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。


 基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。
 由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

"""

def func_time(func):
    def innrer(*args, **kwargs):
        start_time = time.time()
        result = func(*args, *kwargs)
        end_time = time.time()
        print('函数运行时间为：', end_time - start_time, 's')
        return result

    return innrer


@func_time
def main(arr: list):
    """
    :param arr: 需要排序的列表 长度大于1
    :return:
    """
    # 判断参数
    if len(arr) <= 1:
        return arr
    max_num = max(arr)
    place = 1

    while max_num >= 10 ** place:
        place += 1
    for i in range(place):
        buckets = [[] for _ in range(10)]
        for num in arr:
            radix = int(num / (10 ** i) % 10)
            buckets[radix].append(num)
        j = 0
        for k in range(10):
            for num in buckets[k]:
                arr[j] = num
                j += 1
    return arr



if __name__ == '__main__':
    arr = [random.randint(0, 10000) for i in range(10)]
    print("排序前列表：", arr)
    arr = main(arr)
    print("排序后列表：", arr)

11、桶排序：

package main

import (
	"log"
	"math/rand"
)

/*
木桶排序

木桶排序的核心思想

关键词：分桶

将数组分到有限数量的桶子里，每个桶子再个别排序。

其实木桶排序和基数排序很相似，区别在于基数排序需要多趟桶排序，并且记录当前排序的结果。
*/

func selectMax(arr []int) (min, max int) {

	if len(arr) == 0 {
		return 0, 0
	}

	min = arr[0]
	max = arr[1]

	for i := 0; i < len(arr); i++ {
		if arr[i] > arr[0] {
			max = arr[i]
		}
		if arr[i] < arr[0] {
			min = arr[i]
		}

	}
	return min, max

}

func selectSort(arr []int) []int {
	// 复习选择排序
	lenth := len(arr)

	if lenth <= 1 {
		return arr
	}

	for i := 0; i < lenth-1; i++ {
		min := 1
		for j := i + 1; j < lenth; j++ {
			if arr[min] > arr[j] {
				min = j
			}
		}
		if i != min {
			arr[i], arr[min] = arr[min], arr[i]
		}
	}
	return arr

}

func buckSort(arr []int) []int {
	length := len(arr)
	if length <= 1 {
		return arr
	}
	num := length // 长度

	min, max := selectMax(arr)
	log.Println(max, min)

	index := 0

	buckets := make([][]int, num)

	for i := 0; i < length; i++ {
		index = arr[i] * (num - 1) / max
		buckets[index] = append(buckets[index], arr[i])

	}

	log.Println(buckets)

	// 木桶排序
	tmppose := 0

	for i := 0; i < num; i++ {
		bucketslen := len(buckets[i])
		if bucketslen > 0 {
			buckets[i] = selectSort(buckets[i])
			copy(arr[tmppose:], buckets[i])
			tmppose += bucketslen
		}
	}

	return arr
}

func main() {

	arr := []int{}

	for i := 0; i < 10; i++ {
		arr = append(arr, rand.Intn(100))
	}
	log.Println(arr)

	arr = buckSort(arr)
	log.Println(arr)
}