冒泡排序
python
def doubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
arr = [64, 34, 25, 12, 22, 11, 90]
doubble_sort(arr)
print("Sorted array is:", arr)输出：
python
Sorted array is: [11, 12, 22, 25, 34, 64, 90]归并排序
python
def merge_sort(arr):
n = len(arr)
if n > 1:
mid = n // 2
L = arr[:mid]
R = arr[mid:]
merge_sort(L)
merge_sort(R)
i = j = k = 0
while i < len(L) and j < len(R):
if L[i] < R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
while j < len(R):
arr[k] = R[j]
j += 1
k += 1
arr = [38, 27, 43, 3, 9, 82, 10]
merge_sort(arr)
print("Sorted array is:", arr)输出：
python
Sorted array is: [3, 9, 10, 27, 38, 43, 82]插入排序
python
def insertion_sort(input_list):
# 1. 遍历未排序区间（从第2个元素开始，索引1到末尾）
for i in range(1, len(input_list)):
# 2. 取出当前未排序区间的第一个元素作为key（要插入的元素）
key = input_list[i]
# 3. j指向已排序区间的最后一个元素（i-1）
j = i - 1
# 4. 向前遍历已排序区间，找到key的插入位置
# 条件：j≥0（不越界）且 key < 已排序元素（需要后移）
while j >= 0 and key < input_list[j]:
# 把已排序元素后移一位（给key腾位置）
input_list[j + 1] = input_list[j]
j -= 1 # 继续向前找
# 5. 把key插入到正确位置（j+1是因为最后一次j多减了1）
input_list[j + 1] = key
# 测试用例
input_list = [12, 11, 13, 5, 6]
insertion_sort(input_list)
print("Sorted array is:", input_list)输出：
python
Sorted array is: [5, 6, 11, 12, 13]shell希尔排序
python
def shell_sort(arr):
# 1. 获取列表长度
n = len(arr)
# 2. 初始化间隔gap为列表长度的一半（核心：分组依据）
gap = n // 2
# 3. 循环：直到gap缩小为0（所有分组排序完成）
while gap > 0:
# 4. 对每个gap分组执行插入排序（从gap位置开始遍历）
for i in range(gap, n):
# 5. 取出当前元素作为待插入的"关键值"
temp = arr[i]
# 6. j指向当前元素的位置，用于向前遍历同组元素
j = i
# 7. 同组内的插入排序逻辑：
# 条件1：j >= gap（不越界）；条件2：前一个同组元素 > temp（需要后移）
while j >= gap and arr[j - gap] > temp:
# 前一个同组元素后移（给temp腾位置）
arr[j] = arr[j - gap]
# 向前移动gap步，继续比较同组元素
j -= gap
# 8. 将temp插入到同组的正确位置
arr[j] = temp
# 9. 缩小间隔（减半），进入下一轮分组排序
gap //= 2
# 测试用例
arr = [12, 34, 54, 2, 3]
shell_sort(arr)
print("Sorted array is:", arr)输出：
python
Sorted array is: [2, 3, 12, 34, 54]选择排序
python
def selection_sort(arr):
# 1. 获取列表长度
n = len(arr)
# 2. 外层循环：确定已排序区间的末尾位置（i是未排序区间的第一个元素索引）
for i in range(n):
# 3. 初始化最小值索引为未排序区间的第一个元素（假设当前第一个是最小）
min_idx = i
# 4. 内层循环：遍历未排序区间，找到最小值的索引
for j in range(i+1, n):
# 如果当前元素比最小值小，更新最小值索引
if arr[j] < arr[min_idx]:
min_idx = j
# 5. 交换：把最小值放到未排序区间的第一个位置（加入已排序区间）
arr[i], arr[min_idx] = arr[min_idx], arr[i]
# 测试用例
arr = [64, 25, 12, 22, 11]
selection_sort(arr)
print("Sorted array is:", arr)输出：
python
Sorted array is: [11, 12, 22, 25, 64]快速排序
python
def quick_sort(arr, low=None, high=None):
# 初始化：第一次调用时设置low和high的默认值（数组首尾索引）
if low is None:
low = 0
if high is None:
high = len(arr) - 1
# 递归终止条件：子数组长度≤1（无需排序）
if low >= high:
return
# 1. 分区操作：返回基准值的最终位置
pivot_index = partition(arr, low, high)
# 2. 递归排序基准值左侧子数组
quick_sort(arr, low, pivot_index - 1)
# 3. 递归排序基准值右侧子数组
quick_sort(arr, pivot_index + 1, high)
def partition(arr, low, high):
"""
分区函数：将数组分为「小于基准值」「基准值」「大于基准值」三部分
:param arr: 待分区数组
:param low: 子数组起始索引
:param high: 子数组结束索引
:return: 基准值的最终索引
"""
# 选第一个元素作为基准值（pivot）
pivot = arr[low]
# 左指针：从low+1开始找大于pivot的元素
left = low + 1
# 右指针：从high开始找小于pivot的元素
right = high
while True:
# 左指针右移：找到第一个大于pivot的元素
while left <= right and arr[left] <= pivot:
left += 1
# 右指针左移：找到第一个小于pivot的元素
while left <= right and arr[right] >= pivot:
right -= 1
# 若左指针超过右指针，分区结束
if left > right:
break
# 交换左右指针指向的元素（把小的放左，大的放右）
arr[left], arr[right] = arr[right], arr[left]
# 把基准值放到最终位置（右指针的位置）
arr[low], arr[right] = arr[right], arr[low]
# 返回基准值索引
return right
# 测试用例
arr = [64, 25, 12, 22, 11, 3, 99, 5]
quick_sort(arr)
print("Sorted array is:", arr) 输出：
python
Sorted array is: [3, 5, 11, 12, 22, 25, 64, 99]