十种排序算法的详解
1. 冒泡排序
- 原理：重复比较相邻的两个元素，将较大的元素逐渐向后移动，直到整个序列有序。
- 示例：对数组
[5, 3, 8, 4, 2]进行冒泡排序。- 第一轮：比较 5 和 3，交换位置得到
[3, 5, 8, 4, 2]；比较 5 和 8，位置不变；比较 8 和 4，交换位置得到[3, 5, 4, 8, 2]；比较 8 和 2，交换位置得到[3, 5, 4, 2, 8]。 - 后续轮次以此类推，直到整个数组有序。
- 第一轮：比较 5 和 3，交换位置得到
- 代码：
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]
return arr
arr = [5, 3, 8, 4, 2]
sorted_arr = bubble_sort(arr)
print(sorted_arr)
2. 选择排序
- 原理：从未排序部分选择最小的元素，并将其放到已排序部分的末尾，直到整个序列有序。
- 示例：对数组
[5, 3, 8, 4, 2]进行选择排序。- 第一轮：找到最小元素 2，与第一个元素 5 交换位置，得到
[2, 3, 8, 4, 5]。 - 第二轮：在剩余元素中找到最小元素 3，位置不变。
- 后续轮次以此类推，直到整个数组有序。
- 第一轮：找到最小元素 2，与第一个元素 5 交换位置，得到
- 代码：
def selection_sort(arr):
n = len(arr)
for i in range(n):
min_idx = i
for j in range(i + 1, n):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
return arr
arr = [5, 3, 8, 4, 2]
sorted_arr = selection_sort(arr)
print(sorted_arr)
3. 插入排序
- 原理：将未排序的元素逐个插入到已排序部分的正确位置，直到整个序列有序。
- 示例：对数组
[5, 3, 8, 4, 2]进行插入排序。- 初始时，将 5 视为已排序部分，取 3 插入到已排序部分，得到
[3, 5, 8, 4, 2]。 - 取 8 插入，位置不变，得到
[3, 5, 8, 4, 2]。 - 取 4 插入，得到
[3, 4, 5, 8, 2]。 - 取 2 插入，得到
[2, 3, 4, 5, 8]。
- 初始时，将 5 视为已排序部分，取 3 插入到已排序部分，得到
- 代码：
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
return arr
arr = [5, 3, 8, 4, 2]
sorted_arr = insertion_sort(arr)
print(sorted_arr)
4. 快速排序
- 原理：通过选取一个基准元素，将序列划分为左右两部分，使得所有左侧元素小于等于基准元素，所有右侧元素大于等于基准元素，然后对左右两部分递归地进行快速排序，直到整个序列有序。
- 示例：对数组
[5, 3, 8, 4, 2]进行快速排序。- 选择 5 作为基准元素，将数组划分为
[3, 4, 2]和[8]，5 处于正确位置。 - 对
[3, 4, 2]继续进行快速排序，选择 3 作为基准元素，划分为[2]和[4]，3 处于正确位置。 - 最终得到有序数组。
- 选择 5 作为基准元素，将数组划分为
- 代码：
def quick_sort(arr):
if len(arr) <= 1:
return arr
else:
pivot = arr[0]
left = [x for x in arr[1:] if x <= pivot]
right = [x for x in arr[1:] if x > pivot]
return quick_sort(left) + [pivot] + quick_sort(right)
arr = [5, 3, 8, 4, 2]
sorted_arr = quick_sort(arr)
print(sorted_arr)
5. 归并排序
- 原理：将序列不断二分为子序列，对子序列进行排序，再将排好序的子序列合并，直到整个序列有序。
- 示例：对数组
[5, 3, 8, 4, 2]进行归并排序。- 二分得到
[5, 3]和[8, 4, 2]。 - 继续二分
[5, 3]得到[5]和[3]，合并为[3, 5]；二分[8, 4, 2]得到[8]和[4, 2]，再二分[4, 2]得到[4]和[2]，合并为[2, 4]，再与[8]合并为[2, 4, 8]。 - 最后合并
[3, 5]和[2, 4, 8]得到[2, 3, 4, 5, 8]。
- 二分得到
- 代码：
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
arr = [5, 3, 8, 4, 2]
sorted_arr = merge_sort(arr)
print(sorted_arr)
6. 堆排序
- 原理：利用堆数据结构实现的一种排序算法。通过构建最大堆或最小堆，在每一次迭代中将堆顶元素与末尾元素交换，并重新调整堆，直到整个序列有序。
- 示例：对数组
[5, 3, 8, 4, 2]进行堆排序。- 构建最大堆得到
[8, 5, 3, 4, 2]。 - 交换堆顶元素 8 和末尾元素 2，得到
[2, 5, 3, 4, 8]，调整堆得到[5, 4, 3, 2, 8]。 - 重复上述步骤，直到整个数组有序。
- 构建最大堆得到
- 代码：
def heapify(arr, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
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)
return arr
arr = [5, 3, 8, 4, 2]
sorted_arr = heap_sort(arr)
print(sorted_arr)
7. 希尔排序
- 原理：将整个序列分成若干个子序列，对子序列进行插入排序，然后逐步缩小子序列的间隔，直到间隔为1，再对整个序列进行一次插入排序。
- 示例：对数组
[5, 3, 8, 4, 2]进行希尔排序。- 初始间隔为 2，分成子序列
[5, 8, 2]和[3, 4]，分别进行插入排序得到[2, 8, 5]和[3, 4]，合并为[2, 3, 5, 4, 8]。 - 间隔缩小为 1，进行一次插入排序得到
[2, 3, 4, 5, 8]。
- 初始间隔为 2，分成子序列
- 代码：
def shell_sort(arr):
n = len(arr)
gap = n // 2
while gap > 0:
for i in range(gap, n):
temp = arr[i]
j = i
while j >= gap and arr[j - gap] > temp:
arr[j] = arr[j - gap]
j -= gap
arr[j] = temp
gap //= 2
return arr
arr = [5, 3, 8, 4, 2]
sorted_arr = shell_sort(arr)
print(sorted_arr)
8. 计数排序
- 原理：根据待排序序列中元素的大小，在额外开辟的空间中统计每个元素出现的次数，然后根据统计信息对元素进行排序。
- 示例：对数组
[5, 3, 8, 4, 2]进行计数排序。- 找出最大值 8，创建长度为 9 的计数数组
[0, 0, 1, 1, 1, 1, 0, 0, 1]。 - 对计数数组进行累加得到
[0, 0, 1, 2, 3, 4, 4, 4, 5]。 - 根据计数数组将元素放入新数组，得到
[2, 3, 4, 5, 8]。
- 找出最大值 8，创建长度为 9 的计数数组
- 代码：
def counting_sort(arr):
max_val = max(arr)
count = [0] * (max_val + 1)
output = [0] * len(arr)
for num in arr:
count[num] += 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
return output
arr = [5, 3, 8, 4, 2]
sorted_arr = counting_sort(arr)
print(sorted_arr)
9. 桶排序
- 原理：将待排序序列划分为若干个桶，并对每个桶进行排序，最后依次取出各个桶中的元素得到有序序列。
- 示例：对数组
[5, 3, 8, 4, 2]进行桶排序。- 假设划分为 2 个桶，
[2, 3, 4]放入一个桶，[5, 8]放入另一个桶。 - 对每个桶进行排序，然后合并得到
[2, 3, 4, 5, 8]。
- 假设划分为 2 个桶，
- 代码：
def bucket_sort(arr):
max_val = max(arr)
min_val = min(arr)
bucket_range = (max_val - min_val) / len(arr)
buckets = [[] for _ in range(len(arr) + 1)]
for num in arr:
index = int((num - min_val) // bucket_range)
buckets[index].append(num)
sorted_arr = []
for bucket in buckets:
bucket.sort()
sorted_arr.extend(bucket)
return sorted_arr
arr = [5, 3, 8, 4, 2]
sorted_arr = bucket_sort(arr)
print(sorted_arr)
10. 基数排序
- 原理：按照元素的位数进行排序，从低位到高位依次比较。
- 示例：对数组
[5, 3, 8, 4, 2]进行基数排序。- 按个位排序得到
[2, 3, 4, 5, 8]。 - 由于都是一位数，排序完成。
- 按个位排序得到
- 代码：
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
return arr
arr = [5, 3, 8, 4, 2]
sorted_arr = radix_sort(arr)
print(sorted_arr)
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
