Python 实现排序算法

# 冒泡排序，时间复杂度为O(n^2)，空间复杂度为O(1)，稳定
def bubble_sort(arr):
	for i in range(len(arr)):
		for j in range(len(arr)-1-i):
			if arr[j] > arr[j+1]:
				arr[j], arr[j+1] = arr[j+1], arr[j]
	return arr


# 选择排序，时间复杂度为O(n^2)，空间复杂度为O(1)，不稳定
def selection_sort(arr):
	for i in range(len(arr)):
		min_index = i
		for j in range(i+1, len(arr)):
			if arr[j] < arr[min_index]:
				min_index = j
		arr[min_index], arr[i] = arr[i], arr[min_index]
	return arr	


# 插入排序，时间复杂度为O(n^2)，空间复杂度为O(1)，稳定
def insertion_sort(arr):
	for i in range(1, len(arr)):
		cur = arr[i]
		pre_index = i-1
		while pre_index >=0 and arr[pre_index] > cur:
			arr[pre_index + 1] = arr[pre_index]
			pre_index -= 1
		arr[pre_index+1] = cur
	return arr


# 希尔排序，最坏时间复杂度为O(n^2)，平均时间复杂度为O(n^1.3)，空间复杂度为O(1)，不稳定
def shell_sort(arr):
	gap = len(arr) // 2
	while gap > 0:
		for i in range(gap, len(arr)):
			cur = arr[i]
			j = i
			while j - gap >= 0 and cur < arr[j-gap]:
				arr[j] = arr[j-gap]
				j -= gap
			arr[j] = cur
		gap //= 2
	return arr


# 归并排序，时间复杂度为O(nlog(n))，空间复杂度为O(n)，稳定
def merge_sort(arr):
	if len(arr) == 1:
		return arr
	mid = len(arr) // 2
	return merge(merge_sort(arr[:mid]), merge_sort(arr[mid:]))

# 本质就是合并两个有序数组
def merge(left, right):
	res = []
	while len(left) > 0 and len(right) > 0:
		if left[0] <= right[0]:
			res.append(left.pop(0))
		else:
			res.append(right.pop(0))
	res += left
	res += right
	return res


# 快速排序
def quick_sort(arr):


# 堆排序


# 桶排序