十大排序算法（python版）

n：数据规模

k：“桶”的个数

In-place：占用常数内存，不占用额外内存

Out-place：占用额外内存

稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

一、冒泡排序

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


print('bubbleSort', bubbleSort([1, 9, 10, 3, 7, 4, 6]))
#性质：1、时间复杂度：O(n2)  2、空间复杂度：O(1)  3、稳定排序  4、原地排序

二、选择排序

def selectionSort(nums):
    for i in range(len(nums) - 1):
        minIndex = i
        for j in range(i + 1, len(nums)):
            if nums[j] < nums[minIndex]:
                minIndex = j
        if i != minIndex:
            nums[i], nums[minIndex] = nums[minIndex], nums[i]
    return nums


print('selectionSort', selectionSort([1, 9, 10, 3, 7, 4, 6]))

三、插入排序

def insertionSort(nums):
    for i in range(len(nums)):
        curIndex = i
        while curIndex - 1 >= 0:
            if nums[curIndex - 1] > nums[curIndex]:
                nums[curIndex], nums[curIndex - 1] = nums[curIndex - 1], nums[curIndex]
            curIndex -= 1
    return nums


print('insertionSort', insertionSort([1, 9, 10, 3, 7, 4, 6]))

四、希尔排序 

def shellSort(nums):
    gap = int(len(nums) // 2)
    while gap >= 1:
        for i in range(gap, len(nums)):
            j = i - gap
            while j >= 0:
                if nums[j] > nums[j + gap]:
                    nums[j], nums[j + gap] = nums[j + gap], nums[j]
                j -= gap
        gap = int(gap // 2)
    return nums


print('shellSort', shellSort([1, 9, 10, 3, 7, 4, 6]))

五、归并排序

def mergeSort(nums):
    if len(nums) == 1:
        return nums
    left = mergeSort(nums[:len(nums) // 2])
    right = mergeSort(nums[len(nums) // 2:])
    return merge(left, right)


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


print('mergeSort', mergeSort([1, 9, 10, 3, 7, 4, 6]))

六、快速排序

def quickSort(nums, left, right):
    if left < right:
        mid = partition(nums, left, right)
        quickSort(nums, left, mid - 1)
        quickSort(nums, mid + 1, right)
    return nums


def partition(nums, left, right):
    pre = left + 1
    rear = right
    while True:
        while pre <= rear and nums[pre] <= nums[left]:
            pre += 1
        while pre <= rear and nums[rear] >= nums[left]:
            rear -= 1
        if pre > rear:
            break
        nums[pre], nums[rear] = nums[rear], nums[pre]
    nums[left], nums[rear] = nums[rear], nums[left]
    return rear


print('quickSort', quickSort([1, 9, 10, 3, 7, 4, 6], 0, 6))

七、堆排序

def big_heap(nums, start, end):
    root = start
    child = root * 2
    while child <= end:
        if child + 1 <= end and nums[child] < nums[child + 1]:
            child += 1
        if nums[root] < nums[child]:
            nums[root], nums[child] = nums[child], nums[root]
            root = child
            child = root * 2
        else:
            break


def heapSort(nums):
    nums = [0] + nums
    start = (len(nums) - 1) // 2
    for i in range(start):
        big_heap(nums, start - i, len(nums) - 1)
    for i in range(len(nums) - 1):
        nums[1], nums[len(nums) - i - 1] = nums[len(nums) - i - 1], nums[1]
        big_heap(nums, 1, len(nums) - i - 2)
    return nums[1:]


print('heapSort', heapSort([1, 9, 10, 3, 7, 4, 6]))

八、计数排序

def countingSort(nums):
    bucket = [0] * (max(nums) + 1)
    sortedIndex = 0
    for item in nums:
        bucket[item] += 1
    for i in range(len(bucket)):
        while bucket[i] > 0:
            nums[sortedIndex] = i
            sortedIndex += 1
            bucket[i] -= 1
    return nums


print('countingSort', countingSort([1, 9, 10, 3, 7, 4, 6]))

九、桶排序

def bucketSort(nums, volume):
    minNum, maxNum = min(nums), max(nums)
    bucketNum = (maxNum - minNum) // volume + 1
    buckets = [[] for _ in range(int(bucketNum))]
    for num in nums:
        buckets[int((num - minNum) // volume)].append(num)
    new_nums = list()
    for i in buckets:
        for j in sorted(i):
            new_nums.append(j)
    return new_nums


print('bucketSort', bucketSort([1, 9, 10, 3, 7, 4, 6], 10))

十、基数排序

def radixSort(nums):
    maxNum = max(nums)
    place = 1
    while maxNum >= 10 ** place:
        place += 1
    for i in range(place):
        buckets = [[] for _ in range(10)]
        for num in nums:
            radix = int(num / (10 ** i) % 10)
            buckets[radix].append(num)
        index = 0
        for k in range(10):
            for num in buckets[k]:
                nums[index] = num
                index += 1
    return nums


print('radixSort', radixSort([1, 9, 10, 3, 7, 4, 6]))