什么是归并排序
归并排序(Merge Sort)是一种经典的排序算法,它采用分治法(Divide and Conquer)策略,将一个大数组分为两个小数组,分别进行排序,然后将这两个已排序的小数组合并成一个有序的大数组。归并排序在最坏情况下的时间复杂度为 O(nlogn)O(nlogn),并且是一种稳定的排序算法。
核心思想
归并排序的核心思想可以分为以下几个步骤:
- 分解(Divide):将待排序的数组分为两个子数组,直到每个子数组只包含一个元素。因为一个元素的数组是有序的。
- 解决(Conquer):递归地对这两个子数组进行归并排序。
- 合并(Merge):将两个已排序的子数组合并成一个有序的数组。
快速排序与归并排序的比较
快速排序和归并排序都是经典的排序算法,均采用分治法(Divide and Conquer)的思想。尽管它们在基本原理上相似,但在实现细节、性能特征及适用场景上存在显著差异。
1. 基本思路
- 快速排序:
- 选择一个基准元素(Pivot),通常是数组的第一个元素或随机选择。
- 将数组分为两个部分:左侧部分包含小于基准的元素,右侧部分包含大于基准的元素。
- 递归地对这两个部分进行快速排序,直到整个数组有序。
- 归并排序:
- 将数组递归分为两个子数组,直到每个子数组只包含一个元素。
- 然后将这两个已排序的子数组合并成一个有序的数组。
- 合并过程是关键,它需要额外的空间来存放临时数组。
2. 稳定性
- 快速排序:不稳定排序。在排序过程中,相等元素的相对顺序可能会被改变。
- 归并排序:稳定排序。相等元素的相对顺序在排序后保持不变,这在某些应用中非常重要。
示例一
题目描述
代码实现
import java.util.Scanner;public class Main {final static int N = 1000000;private static int[] temp = new int[N];public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int arr[] = new int[n];for (int i = 0; i < n; i++) {arr[i] = scanner.nextInt();}mergeSort(arr, 0, n - 1);for (int i = 0; i < n; i++) {System.out.print(arr[i] + " ");}}public static void mergeSort(int[] arr, int l, int r) {if (l >= r) return;int mid = (l + r) >> 1;mergeSort(arr, l, mid);mergeSort(arr, mid + 1, r);int k = 0, i = l, j = mid + 1;while (i <= mid && j <= r) {if (arr[i] <= arr[j])temp[k++] = arr[i++];elsetemp[k++] = arr[j++];}//将剩余元素复制到temp数组中while (i <= mid) temp[k++] = arr[i++];while (j <= r) temp[k++] = arr[j++];//将temp数组中的元素复制回arr数组for (int t = l; t <= r; t++)arr[t] = temp[t - l];}
}
示例二
题目描述
求逆序对的数量
代码实现
import java.util.Scanner;public class Main {final static int N = 1000000;private static int[] temp = new int[N];public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int arr[] = new int[n];for (int i = 0; i < n; i++) {arr[i] = scanner.nextInt();}scanner.close();System.out.println(mergeSort(arr, 0, n - 1));}public static long mergeSort(int[] arr, int l, int r) {if (l >= r) return 0;int mid = (l + r) >> 1;long res = mergeSort(arr, l, mid)+mergeSort(arr, mid + 1, r);int k = 0, i = l, j = mid + 1;while (i <= mid && j <= r) {if (arr[i] <= arr[j])temp[k++] = arr[i++];else{res += (mid - i + 1);temp[k++] = arr[j++];}}while (i <= mid)temp[k++] = arr[i++];while (j <= r)temp[k++] = arr[j++];for(i=l,j=0;i<=r;i++,j++)arr[i]=temp[j];return res;}
}
逆序对数量算法思路与实现
求逆序对的算法是利用了归并排序的思想,在归并排序的过程中会将序列分为两部分,此时逆序对可以分为三种情况:两个数都在左边的(设为s1)。两个数都在右边的(s2),一个数在左边一个数在右边的(s3)。现在假设我们在归并排序的时候写的函数mergeSort(int[] arr, int l, int r)可以返回l到r区间中逆序对数量。那么s1=mergeSort(a, l, mid),s2=mergeSort(a, mid + 1, r);,s3很显然没有直观的答案。
那么核心问题就在于怎么求s3,以及怎么使我们的mergeSort(int[] arr, int l, int r)可以返回l到r区间中逆序对数量。
在归并排序中,左右两边都是排序好的数列。因此,对于右图中的B我们只需要找到左边第一个大于B的数A,那么A后面的数都是大于B的。假设A的下标为i,不难得到我们要统计的数目为:mid-i+1,else中的语句即代表左边数列中的数大于右边中的数了,我们可以在此时将mid-i+1加到总答案中去。那么s3的问题就解决了。经过递归之后,res 即我们所求。
时间复杂度
- 最佳情况:O(nlogn)O(nlogn)
- 平均情况:O(nlogn)O(nlogn)
- 最坏情况:O(nlogn)O(nlogn)
归并排序在所有情况下的时间复杂度都是 O(nlogn)O(nlogn),这使得它在处理大规模数据时非常高效。
空间复杂度
归并排序的空间复杂度为 O(n)O(n),因为在合并过程中需要额外的存储空间来存放临时数组。
优点:
- 稳定排序,能够保持相等元素的相对顺序。
- 在处理大规模数据时,性能稳定。
缺点:
- 需要额外的存储空间,不适合内存受限的环境。
应用场景
归并排序广泛用于需要稳定排序的场合,如外部排序(处理无法完全放入内存的数据集)和链表排序。由于其稳定性和性能,归并排序在许多编程语言的标准库中被实现为排序算法。
总结
归并排序是一种高效且稳定的排序算法,适用于大规模数据的排序。通过分治法的思想,归并排序能够在最坏情况下保持 O(nlogn)O(nlogn) 的时间复杂度。虽然它需要额外的空间,但在许多实际应用中,归并排序仍然是一种非常有用的算法。