Java实现归并排序算法
1. 归并排序原理图解
归并排序是一种分治算法，其核心思想是将数组分成两半，分别对这两半进行排序，然后将排序后的两半合并。以下是归并排序的步骤：
1. 分治：
- 将数组分成两半。
- 递归地对每半部分进行归并排序。
2. 合并：
- 将两个已排序的子数组合并成一个排序后的数组。
图解示例：
假设数组为 `[38, 27, 43, 3, 9, 82, 10]`。
1. 初始状态：`[38, 27, 43, 3, 9, 82, 10]`
2. 分治过程：
- 分成两半：`[38, 27, 43]` 和 `[3, 9, 82, 10]`
- 继续分治：
- 左半部分：`[38]` 和 `[27, 43]`
- 右半部分：`[3, 9]` 和 `[82, 10]`
3. 合并过程：
- 合并左半部分：`[27, 38, 43]`
- 合并右半部分：`[3, 9, 10, 82]`
- 最终合并：`[3, 9, 10, 27, 38, 43, 82]`
2. Java代码实现及注释
```java
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
int[] array = {38, 27, 43, 3, 9, 82, 10};
mergeSort(array);
System.out.println("排序后的数组：");
System.out.println(Arrays.toString(array));
}
// 归并排序主方法
public static void mergeSort(int[] arr) {
if (arr.length < 2) {
return;
}
int mid = arr.length / 2;
int[] left = Arrays.copyOfRange(arr, 0, mid);
int[] right = Arrays.copyOfRange(arr, mid, arr.length);
// 递归排序左右两部分
mergeSort(left);
mergeSort(right);
// 合并排序后的两部分
merge(arr, left, right);
}
// 合并两个已排序的数组
private static void merge(int[] arr, int[] left, int[] right) {
int i = 0, j = 0, k = 0;
while (i < left.length && j < right.length) {
if (left[i] <= right[j]) {
arr[k++] = left[i++];
} else {
arr[k++] = right[j++];
}
}
while (i < left.length) {
arr[k++] = left[i++];
}
while (j < right.length) {
arr[k++] = right[j++];
}
}
}
```
3. 代码说明
1. 分治过程：
- 将数组分成两半，递归地对每半部分进行排序。
2. 合并过程：
- 使用两个指针分别遍历两个已排序的子数组，将较小的元素依次放入结果数组中。
- 处理剩余元素，将未遍历完的子数组中的元素直接复制到结果数组中。
3. 时间复杂度：
- **最坏情况**：`O(n log n)`。
- **平均情况**：`O(n log n)`。
- **最好情况**：`O(n log n)`。
4. 空间复杂度：
- `O(n)`，因为需要额外的数组空间来存储子数组。
5. 稳定性：
- 归并排序是**稳定的**，因为合并过程中相同值的元素的相对顺序不会改变。
4. 应用场景
1. 大规模数据排序：
- 归并排序的时间复杂度稳定在 `O(n log n)`，适合对大规模数据进行排序。
2. 外部排序：
- 归并排序适合用于外部排序，即数据量大于内存容量时的排序。
3. 需要稳定性的排序：
- 当需要保持相同值元素的相对顺序时，归并排序是一个不错的选择。
4. 教学和演示：
- 归并排序的实现清晰，适合用于教学和算法演示。
5. 总结
归并排序是一种高效的分治排序算法，具有稳定的时间复杂度和稳定性。它的主要缺点是需要额外的内存空间来存储子数组。在实际应用中，归并排序适用于大规模数据排序和需要稳定性的场景。