python 排序算法

1、冒泡排序

def bubbleSort(nums):
	for i in range(len(nums)-1):  #只需进行length-1轮
		for j in range(len(nums)-i-1):  #后面i个已经排好序
			if nums[j]>nums[j+1]:
				nums[j], nums[j+1] = nums[j+1], nums[j]
	return nums

2、选择排序

#这种写法每次if条件成立时都会进行一次交换
def selectSort1(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

#这种写法通过增加一个中间变量，使得每一轮（即对每一个i）只交换一次
def selectSort2(nums):
	for i in range(len(nums)-1):
		min_idx = i
		for j in range(i+1, len(nums)):
			if nums[j]<nums[min_idx]:
				min_idx = j
		nums[i], nums[min_idx] = nums[min_idx], nums[i]
	return nums

3、插入排序

#这种写法无需中间变量
def insertSort(nums):
	for i in range(1, len(nums)):  #从第二个数开始，找到该去的位置
		for j in range(i-1, -1, -1):
			if nums[j]>nums[j+1]:
				nums[j], nums[j+1] = nums[j+1], nums[j]
			else:  #如果前面排好序，直接跳出
				break
	return nums

4、希尔排序

#插入排序加一层循环
def shellSort(nums):
	dist = len(nums) // 2
	while dist>0:
		for i in range(dist, len(nums)):
			for j in range(i-dist, -1, -dist):
				if nums[j]>nums[j+dist]:
					nums[j], nums[j+dist] = nums[j+dist], nums[j]
				else:
					break
		dist //= 2
	return nums

5、归并排序

def mergeSort(nums):
	def merge(left, right):
		res = []
		i = 0
		j = 0
		while i<len(left) and j<len(right):
			if left[i]<=right[j]:
				res.append(left[i])
				i += 1
			else:
				res.append(right[j])
				j += 1
		return res + left[i:] + right[j:]
		
	if len(nums)<=1:  #必须加这个，否则如果length=1会死循环
		return nums
	mid = len(nums) // 2
	left = mergeSort(nums[:mid])
	right = mergeSort(nums[mid:])
	return merge(left, right)

6、快速排序

def quickSort(nums, left, right):
	def partion(nums, left, right):
		tmp = nums[left]
		while left<right:
			while left<right and nums[right]>=tmp:
				right -= 1
			nums[left] = nums[right]
			while left<right and nums[left]<=tmp:
				left += 1
			nums[right] = nums[left]
		nums[right] = tmp
		return left
		
	if left<right:
		base = partion(nums, left, right)
		quickSort(nums, left, base-1)
		quickSort(nums, base+1, right)
		return nums

7、堆排序

def heapSort(nums):  # 用大根堆（当前节点值>=子节点值），做升序排序
	def adjustHeap(nums, i, length):
		# 非叶子节点的左、右孩子
		left = 2 * i + 1
		right = 2 * i + 2
		# 找到当前节点与两个孩子中的最大值
		largest = i
		if left<length and nums[left]>nums[largest]:
			largest = left
		if right<length and nums[right]>nums[largest]:
			largest = right
		# 如果最大值不是当前节点，交换，继续调整堆
		if largest!=i:
			nums[largest], nums[i] = nums[i], nums[largest]
			adjustHeap(nums, largest, length)
			
	for i in range(len(nums)//2 - 1, -1, -1):  #建立堆，从最后一个非叶子节点开始
		adjustHeap(nums, i, len(nums))
	for i in range(len(nums)-1, -1, -1):  #排序，每次取最大数（根节点），然后调整堆
		nums[i], nums[0] = nums[0], nums[i]
		adjustHeap(nums, 0, i)
	return nums

8、计数排序

def countSort(nums):
	bucket = [0] * (max(nums)-min(nums)+1)
	for n in nums:
		bucket[n-min(nums)] += 1
	i = 0
	for j in range(len(bucket)):
		while bucket[j]>0:
			nums[i] = j + min(nums)
			bucket[j] -= 1
			i += 1
	return nums

9、桶排序

def bucketSort(nums, bucketSize = 2):
    bucketCount = (max(nums) - min(nums)) // bucketSize + 1  #数据分为bucketCount组
    buckets = []  # 二维桶
    for i in range(bucketCount):
        buckets.append([])
    # 利用函数映射将各个数据放入对应的桶中
    for num in nums:
        buckets[(num - min(nums)) // bucketSize].append(num)
    nums.clear()  # 清空 nums
    # 对每一个二维桶中的元素进行排序
    for bucket in buckets:
        insertionSort(bucket)  # 假设使用插入排序
        nums.extend(bucket)    # 将排序好的桶依次放入到 nums 中
    return nums

10、基数排序

def radixSort(nums):
    mod = 10
    div = 1
    mostBit = len(str(max(nums)))  # 最大数的位数决定了外循环多少次
    buckets = [[] for row in range(mod)] # 构造 mod 个空桶
    while mostBit:
        for num in nums:  # 将数据放入对应的桶中
            buckets[num // div % mod].append(num)
        i = 0  # nums 的索引
        for bucket in buckets:  # 将数据收集起来
            while bucket:
                nums[i] = bucket.pop(0) # 依次取出
                i += 1
        div *= 10
        mostBit -= 1
    return nums