### 六大经典排序算法详解及其实现
#### 1. 堆排序 (Heap Sort)
堆排序是一种基于堆数据结构的选择排序算法。该算法通过构建最大堆或最小堆来逐步将数组中的元素按顺序排列[^2]。
```python
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 heapSort(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)
```
#### 2. 归并排序 (Merge Sort)
归并排序采用分治法的思想，将待排序序列分成若干子序列分别排序再合并。这种方法适用于大规模数据集的排序操作[^1]。
```python
def merge_sort(lst):
if len(lst) <= 1:
return lst
mid = len(lst) // 2
left_half = merge_sort(lst[:mid])
right_half = merge_sort(lst[mid:])
return merge(left_half, right_half)
def merge(left, right):
sorted_list = []
while left and right:
if left[0] < right[0]:
sorted_list.append(left.pop(0))
else:
sorted_list.append(right.pop(0))
while left:
sorted_list.append(left.pop(0))
while right:
sorted_list.append(right.pop(0))
return sorted_list
```
#### 3. 快速排序 (Quick Sort)
快速排序也是一种高效的分治类排序算法，在实际应用中表现良好。其核心在于选取合适的基准值，并以此为基础划分输入列表[^4]。
```python
def quicksort(array):
if len(array) < 2:
return array
else:
pivot = array[0]
less = [i for i in array[1:] if i <= pivot]
greater = [i for i in array[1:] if i > pivot]
return quicksort(less) + [pivot] + quicksort(greater)
```
#### 4. 插入排序 (Insertion Sort)
插入排序适合处理较小规模的数据集合或者几乎已经有序的情况。它的工作机制类似于人们整理手中的扑克牌。
```python
def insertion_sort(nums):
for i in range(len(nums)):
j = i
while j>0 and nums[j-1] > nums[j]:
nums[j-1],nums[j]=nums[j],nums[j-1]
j -= 1
return nums
```
#### 5. 冒泡排序 (Bubble Sort)
冒泡排序是最简单的交换型排序之一，尽管效率不高但在教学场景中有一定价值。此方法重复遍历要排序的数列，依次比较相邻两个元素大小并互换位置直到整个序列变得有序为止。
```python
def bubble_sort(nums):
for i in range(len(nums)-1):
for j in range(len(nums)-i-1):
if nums[j]>nums[j+1]:
nums[j],nums[j+1]=nums[j+1],nums[j]
return nums
```
#### 6. 外部排序 (External Sorting)
当面对海量数据无法一次性加载到内存时，则需借助磁盘文件完成排序工作。外部排序通常会涉及到多趟读写以及归并过程，因此设计合理的I/O策略至关重要[^3]。
```python
import heapq
def external_merge_sort(files_chunked_sorted_paths, output_file_path='output.txt'):
with open(output_file_path,'w') as f_out:
file_handles = [open(file_name) for file_name in files_chunked_sorted_paths]
min_heap = []
try:
for idx,file_handle in enumerate(file_handles):
line=file_handle.readline().strip()
if line:
heapq.heappush(min_heap,(int(line),idx))
while min_heap:
val,idx=heapq.heappop(min_heap)
f_out.write(str(val)+'\n')
next_line=file_handles[idx].readline().strip()
if next_line:
heapq.heappush(min_heap,(int(next_line),idx))
finally:
for fh in file_handles:
fh.close()
```
博客主要提及外部排序，但内容待续。外部排序是信息技术领域重要内容，后续可能会详细阐述其原理、方法等关键信息。
扫一扫
273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
