-
冒泡排序（Bubble Sort）：
- 基本思想：通过比较相邻元素的大小，不断交换相邻元素的位置，使得较大的元素逐渐"浮"到数组的最后。
- 时间复杂度：O(n^2)。
-
选择排序（Selection Sort）：
- 基本思想：每一次从未排序的部分中选择最小的元素，将其放在已排序部分的末尾。
- 时间复杂度：O(n^2)。
-
插入排序（Insertion Sort）：
- 基本思想：将数组分为已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的合适位置。
- 时间复杂度：O(n^2)。
-
快速排序（Quick Sort）：
- 基本思想：通过选择一个基准元素，将数组划分为左右两部分，左边的元素都小于基准，右边的元素都大于基准，然后递归地对左右两部分进行排序。
- 时间复杂度：平均情况下为O(n log n)。
-
归并排序（Merge Sort）：
- 基本思想：将数组分成两个部分，分别对这两个部分进行排序，然后合并这两个有序的部分。
- 时间复杂度：始终为O(n log n)，但需要额外的空间。
-
堆排序（Heap Sort）：
- 基本思想：利用堆的数据结构，将数组看作一个二叉堆，然后利用堆的性质进行排序。
- 时间复杂度：O(n log n)。
-
计数排序（Counting Sort）：
- 基本思想：对每一个输入元素x，确定小于x的元素个数，从而确定x在输出序列中的位置。
- 时间复杂度：O(n + k)，其中k是最大元素的范围。
-
基数排序（Radix Sort）：
- 基本思想：从低位到高位，对输入元素进行多次排序，每次都是根据某一位上的数值进行排序。
- 时间复杂度：O(d * (n + k))，其中d是最大数字的位数，k是进制。
简单代码示例：
- 冒泡排序（Bubble Sort）：
python
def bubble_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]
bubble_sort(arr)
print("冒泡排序结果:", arr)- 选择排序（Selection Sort）：
python
def selection_sort(arr):
n = len(arr)
for i in range(n):
min_index = i
for j in range(i+1, n):
if arr[j] < arr[min_index]:
min_index = j
arr[i], arr[min_index] = arr[min_index], arr[i]
# 示例
arr = [64, 25, 12, 22, 11]
selection_sort(arr)
print("选择排序结果:", arr)- 插入排序（Insertion Sort）：
python
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
# 示例
arr = [12, 11, 13, 5, 6]
insertion_sort(arr)
print("插入排序结果:", arr)- 快速排序（Quick Sort）：
python
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
# 示例
arr = [3, 6, 8, 10, 1, 2, 1]
result = quick_sort(arr)
print("快速排序结果:", result)- 堆排序（Heap Sort）：
python
def heapify(arr, n, i):
largest = i
left = 2 * i + 1
right = 2 * i + 2
if left < n and arr[i] < arr[left]:
largest = left
if right < n and arr[largest] < arr[right]:
largest = right
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
def heap_sort(arr):
n = len(arr)
for i in range(n // 2 - 1, -1, -1):
heapify(arr, n, i)
for i in range(n - 1, 0, -1):
arr[i], arr[0] = arr[0], arr[i]
heapify(arr, i, 0)
# 示例
arr = [12, 11, 13, 5, 6, 7]
heap_sort(arr)
print("堆排序结果:", arr)- 归并排序（Merge Sort）：
python
def merge_sort(arr):
if len(arr) > 1:
mid = len(arr) // 2
left_half = arr[:mid]
right_half = arr[mid:]
merge_sort(left_half)
merge_sort(right_half)
i = j = k = 0
while i < len(left_half) and j < len(right_half):
if left_half[i] < right_half[j]:
arr[k] = left_half[i]
i += 1
else:
arr[k] = right_half[j]
j += 1
k += 1
while i < len(left_half):
arr[k] = left_half[i]
i += 1
k += 1
while j < len(right_half):
arr[k] = right_half[j]
j += 1
k += 1
# 示例
arr = [12, 11, 13, 5, 6, 7]
merge_sort(arr)
print("归并排序结果:", arr)- 计数排序（Counting Sort）：
python
def counting_sort(arr):
output = [0] * len(arr)
count = [0] * (max(arr) + 1)
for i in arr:
count[i] += 1
for i in range(1, len(count)):
count[i] += count[i - 1]
i = len(arr) - 1
while i >= 0:
output[count[arr[i]] - 1] = arr[i]
count[arr[i]] -= 1
i -= 1
for i in range(len(arr)):
arr[i] = output[i]
# 示例
arr = [4, 2, 2, 8, 3, 3, 1]
counting_sort(arr)
print("计数排序结果:", arr)- 基数排序（Radix Sort）：
python
def counting_sort_for_radix(arr, exp):
n = len(arr)
output = [0] * n
count = [0] * 10
for i in range(n):
index = arr[i] // exp
count[index % 10] += 1
for i in range(1, 10):
count[i] += count[i - 1]
i = n - 1
while i >= 0:
index = arr[i] // exp
output[count[index % 10] - 1] = arr[i]
count[index % 10] -= 1
i -= 1
for i in range(n):
arr[i] = output[i]
def radix_sort(arr):
max_num = max(arr)
exp = 1
while max_num // exp > 0:
counting_sort_for_radix(arr, exp)
exp *= 10
# 示例
arr = [170, 45, 75, 90, 802, 24, 2, 66]
radix_sort(arr)
print("基数排序结果:", arr)