Python数据结构与算法（三）：十大排序算法（包含思路、图解和代码）

import time
import random
# 普通冒泡排序
def bubble(nums):
    for i in range(len(nums)-1,0,-1):
        for j in range(i):
            if nums[j] > nums[j+1]:
                # 交换
                temp = nums[j]
                nums[j] = nums[j+1]
                nums[j+1] = temp
    return nums

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
bubble(nums)
print(time.time()-start1)

# 优化冒泡排序
def shortbubble(nums):
    exchanges = True
    passnum = len(nums) - 1
    while passnum > 0 and exchanges:
        exchanges = False
        for j in range(passnum):
            if nums[j] > nums[j+1]:
                exchanges = True
                temp = nums[j]
                nums[j] = nums[j+1]
                nums[j+1] = temp
        passnum -= 1
    return nums

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start2 = time.time()
shortbubble(nums)
print(time.time()-start2)

4.排序复杂度分析

最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

二、选择排序

1.排序思路

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。排序思路：

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

2.排序图解

3.排序代码

import time
import random
def select(nums):
    for i in range(len(nums)-1,0,-1):
        max_idx = 0
        for j in range(1,i+1):
            if nums[j] > nums[max_idx]:
                max_idx = j
        temp = nums[i]
        nums[i] = nums[max_idx]
        nums[max_idx] = temp

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
select(nums)
print(time.time()-start1)

4.排序复杂度分析

最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

三、插入排序

1.排序思路

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。排序步骤如下：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

2.排序图解

3.排序代码

import time
import random
def insert(nums):
	for idx in range(1,len(nums)):
		cur = nums[idx]
		pos = idx
		while pos > 0 and nums[pos - 1] > cur:
			nums[pos] = nums[pos - 1]
			pos -= 1
		nums[pos] = cur

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
insert(nums)
print(time.time()-start1)

4.排序复杂度分析

最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

四、希尔排序

1.排序思路

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

2.排序图解

3.排序代码

import time
import random
def shell(nums):
    subnum = len(nums) // 2
    while subnum > 0:
        for startpos in range(subnum):
            gapinsert(nums,startpos,subnum)
        # print(subnum,'=>',nums)
        subnum = subnum // 2

# 增量插入排序
def gapinsert(nums,startpos,gap):
    for i in range(startpos+gap,len(nums),gap):
        cur = nums[i]
        pos = i
        while pos >= gap and nums[pos - gap] > cur:
            nums[pos] = nums[pos - gap]
            pos -= gap
        nums[pos] = cur

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
shell(nums)
print(time.time()-start1)

4.排序复杂度分析

最佳情况：T(n) = O(nlog2 n) 最坏情况：T(n) = O(nlog2 n) 平均情况：T(n) =O(nlog2n)　

五、归并排序

1.排序思路

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

把长度为n的输入序列分成两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。

2.排序图解

3.排序代码

import time
import random
def merge(nums):
	if len(nums) > 1:
		mid = len(nums) // 2
		left = nums[:mid]
		right = nums[mid:]
		merge(left)
		merge(right) 
		i = 0;j = 0;k = 0
		while i < len(left) and j < len(right):
			if left[i] < right[j]:
				nums[k] = left[i];i += 1
			else:
				nums[k] = right[j];j += 1
			k += 1
		while i < len(left):
			nums[k] = left[i];i += 1;k += 1
		while j < len(right):
			nums[k] = right[j];j += 1;k += 1

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
merge(nums)
print(nums)
print(time.time()-start1)

4.排序复杂度分析

最佳情况：T(n) = O(n) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)

六、快速排序

1.排序思路

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

2.排序图解

3.排序代码

import time
import random
def quick(nums):
    quickHelper(nums,0,len(nums)-1)

def quickHelper(nums,first,last):
    if first<last:
        split = partition(nums,first,last)
        quickHelper(nums,first,split -1)
        quickHelper(nums,split+1,last)

def partition(nums,first,last):
    pivot = nums[first]
    left = first + 1
    right = last
    done = False
    while not done:
        while left <= right and nums[left] <= pivot:
            left = left + 1
        while nums[right] >= pivot and right >= left:
            right = right -1
        if right < left: 
            done = True
        else:
            temp = nums[left]
            nums[left] = nums[right]
            nums[right] = temp
    temp = nums[first]
    nums[first] = nums[right]
    nums[right] = temp
    return right

# 一行快排解法
# def quick(nums):
#     if len(nums) <= 1:
#         return nums
#     pivot = nums[0]
#     return quick([x for x in nums[1:] if x < pivot]) + [pivot] + quick([x for x in nums[1:] if x >=pivot])

#测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
quick(nums)
print(time.time()-start1)

4.排序复杂度分析

最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(nlogn)　

七、堆排序

1.排序思路

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

2.排序图解

3.排序代码

import time
import random
def heapify(nums, n, i): 
    largest = i  
    l = 2 * i + 1     # left = 2*i + 1 
    r = 2 * i + 2     # right = 2*i + 2 
    if l < n and nums[i] < nums[l]: 
        largest = l 
    if r < n and nums[largest] < nums[r]: 
        largest = r 
    if largest != i: 
        nums[i],nums[largest] = nums[largest],nums[i]  # 交换
        heapify(nums, n, largest)

def heapSort(nums): 
    n = len(nums) 
    # 构建大顶堆
    for i in range(n, -1, -1): 
        heapify(nums, n, i) 
    # 诸个交换元素
    for i in range(n-1, 0, -1): 
        nums[i], nums[0] = nums[0], nums[i]   # 交换
        heapify(nums, i, 0) 

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
heapSort(nums)
print(time.time()-start1)

4.排序复杂度分析

最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)

八、计数排序

1.排序思路

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

找出待排序的数组中最大和最小的元素；
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

2.排序图解

3.排序代码

import time
import random
def count(nums):
	min_num = min(nums)
	max_num = max(nums)
	count_lst = [0]*(max_num-min_num+1)
	for i in nums:
		count_lst[i-min_num] += 1
	nums.clear()
	for idx,i in enumerate(count_lst):
		while i != 0:
			nums.append(idx+min_num)
			i -= 1

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
count(nums)
print(time.time()-start1)
print(nums)

4.排序复杂度分析

最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n+k)

九、桶排序

1.排序思路

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排。

人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
从不是空的桶里把排好序的数据拼接起来。

2.排序图解

3.排序代码

import time
import random
def bucket(nums):
    min_num = min(nums)
    max_num = max(nums)
    lens = len(nums)
    # 桶的大小
    bucket_range = (max_num-min_num) / lens
    # 桶数组
    count_list = [ [] for i in range(lens + 1)]
    # 向桶数组填数
    for i in nums:
        count_list[int((i-min_num)//bucket_range)].append(i)
    nums.clear()
    # 回填，这里桶内部排序直接调用了sorted
    for i in count_list:
        for j in sorted(i):
            nums.append(j)

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
bucket(nums)
print(time.time()-start1)

4.排序复杂度分析

最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n2)　　

十、基数排序

1.排序思路

基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

取得数组中的最大数，并取得位数；
arr为原始数组，从最低位开始取每个位组成radix数组；
对radix进行计数排序（利用计数排序适用于小范围数的特点）；

2.排序图解

3.排序代码

import time
import random
def radix(nums):
    i = 0                                             #初始为个位排序
    n = 1                                           #最小的位数置为1（包含0）
    max_num = max(nums)                       #得到带排序数组中最大数
    while max_num > 10**n:              #得到最大数是几位数
        n += 1
    while i < n:
        bucket = {}                             #用字典构建桶
        for x in range(10):
            bucket.setdefault(x, [])    #将每个桶置空
        for x in nums:                               #对每一位进行排序
            radix =int((x / (10**i)) % 10)   #得到每位的基数
            bucket[radix].append(x) #将对应的数组元素加入到相应位基数的桶中
        j = 0
        for k in range(10):
            if len(bucket[k]) != 0:       #若桶不为空
                for y in bucket[k]:         #将该桶中每个元素
                    nums[j] = y                       #放回到数组中
                    j += 1
        i += 1

# 测试代码
random.seed(1)
nums = [random.randint(1,10000) for i in range(10000)]
start1 = time.time()
radix(nums)
print(time.time()-start1)