归并排序
最近学习了归并排序，也刷了各种归并排序的题，下面进行对于归并排序的理解和刷题的总结。
首先归并排序，主要是运用了分治的思想，通过对数组的拆分和合并达到排序的目的。其主要核心在于合并时的元素比较。
leetcode上的归并排序的题目
刷了很多leetcode归并的题目，其中主要分为两大类。
一类是直接使用归并进行排序和合并的，比如对数组进行排序，合并两个数组，合并链表等等。都是属于直接运用归并排序。
第二类是属于运用合并的思想，在进行元素比较的同时，记录和统计一些数字。比如在leetcode上的求逆序对，求右边的数小于该元素的个数，求小和，统计重要翻转对等等。
今天主要就是对第二类的题型进行区别。
先展示归并排序的原始代码
public int reversePairs(int[] nums) {
if (nums == null || nums.length == 0){
return 0;
}
int l = 0;
int r = nums.length - 1;
int mid = l + ((r - l) >> 1);
//对左字组排序
sort(nums,l,mid) ;
//对右字组排序
sort(nums,mid + 1,r);
//归并
merge(nums,l,mid,r);
}
public void sort(int[] arr,int l,int r){
if (l >= r){
return;
}
int mid = l + ((r - l)>>1);
sort(arr,l,mid) ;
sort(arr,mid + 1,r);
merge(arr,l,mid,r);
}
public void merge(int[] arr,int l,int mid,int r){
if (l >= r){
return;
}
int[] temp = new int[r - l + 1];
int i = l, j = mid + 1;
int index = 0;
while (i <= mid && j <= r) {
temp[index++] = arr[i] > arr[j] ? arr[j++] : arr[i++];
}
while (i <= mid) {
temp[index++] = arr[i++];
}
while (j <= r) {
temp[index++] = arr[j++];
}
for (int k = 0; k < temp.length; k++) {
arr[l + k] = temp[k];
}
}
先看这个逆序对的问题。
逆序对
核心思想：
逆序对，就是求该元素在右边有多少个比他小的数字，在归并中，左子组一定是在右子组的左边，所以天然形成条件。
这总题型是求总和的一类题目，是元素之间直接比较就可以统计出结果
我们就可以利用在合并的比较基础上修改代码，完成题目。
还有一个注意的点就是，就是判断当两个子组在元素比较时相等的时候应该把谁放入辅助数组中。另外一个点是元素的直接比较，还有是返回统计和，这些信息，在不同情况下有不同的体现。
代码如下
class Solution {
int[] helpArr;
public int reversePairs(int[] arr){
int start = 0;
int end = arr.length - 1;
int mid = start + ((end - start) >> 1);
helpArr = new int[arr.length];
//左排序
return process(arr,start,mid) +
//右排序
process(arr,mid + 1,end) +
//合并左右
merge(arr,start,mid,end);
}
public int process(int[] arr,int L,int R){
//当剩一个的时候返回
if (L >= R){
return 0;
}
int M = L + ((R - L) >> 1);
//左排序
return process(arr,L,M) +
//右排序
process(arr, M + 1, R) +
merge(arr,L,M,R);
}
public int merge(int[] arr,int L,int M,int R){
int sum = 0;
int p1 = L;
int p2 = M + 1;
int index = L;
//只有一个数就不用merge了
if (L >= R){
return 0;
}
//放到辅助数组种
//求逆序对的话，那肯定是左边的大于右边的 当相等时，左边入 当左大时，右边入，而且sum++ 当右边大时，左边入
while(p1 <= M && p2 <= R){
if (arr[p1] > arr[p2]){//左边大于右边
helpArr[index++] = arr[p2++];
sum+=(M - p1 + 1);
}else {
helpArr[index++] = arr[p1++];
}
}
//接下来肯定有一组是没有进行的
while(p1 <= M){
helpArr[index++] = arr[p1++];
}
while(p2 <= R){
helpArr[index++] = arr[p2++];
}
for (int i = L; i <= R; i++) {
arr[i] = helpArr[i];
}
return sum;
}
}
这里于上面的大体思想是一样的，也是元素间在合并时直接比较就可以得出结果。
但是有一点不同的是，他统计的是每个元素上的，所以要额外创建一个辅助数组来记录索引的变化，不然无法判断原始位置。
class Solution {
List<Integer> ans = new ArrayList<>(); //记录最终的结果
int[] index; //原数组的索引数组，存储着原数组中每个元素对应的下标
int[] count; //记录题目中所求的count[i]
public List<Integer> countSmaller(int[] nums) {
int len = nums.length;
index = new int[len];
count = new int[len];
for (int i = 0; i < nums.length; i++) {
index[i] = i;
}
mergeSort(nums, 0, nums.length - 1);
return Arrays.stream(count).boxed().collect(Collectors.toList());
}
public void mergeSort(int[] a, int l, int r) {
if (l >= r) {
return;
}
int mid = (l + r) >> 1;
mergeSort(a, l, mid);
mergeSort(a, mid + 1, r);
merge1(a, l, r,mid);
}
private void merge1(int[] nums,int l,int r,int mid){
if (l >= r){
return;
}
int index1 = l;
int index2 = mid + 1;
int i = l;
int[] tmp = new int[nums.length]; //临时数组用于存储一次归并过程中排序好的元素，
int[] tmpIndex = new int[nums.length];//临时数组的索引数组，存储这临时数组中每个元素对应的下标
while(index1 <= mid && index2 <= r) {
if (nums[index1] > nums[index2]) {
count[index[index1]] += (r - index2 + 1);
tmp[i] = nums[index1];
tmpIndex[i] = index[index1];
i++;
index1++;
} else {
tmp[i] = nums[index2];
tmpIndex[i] = index[index2];
i++;
index2++;
}
}
while(index1 <= mid){
tmp[i] = nums[index1];
tmpIndex[i] = index[index1];
i++;
index1++;
}
while(index2 <= r){
tmp[i] = nums[index2];
tmpIndex[i] = index[index2];
i++;
index2++;
}
for (int j = l; j <= r; j++) {
nums[j] = tmp[j];
index[j] = tmpIndex[j];
}
}
求反转对
反转对就是求arr[i] > arr[j] * 2的，而且i < j,
注意，这里并不是元素间的直接比较，他还进行了运算不能在合并过程中直接比较，因为要考虑很多细节，比如负数的情况，
特别的是元素间大小的比较，比如以下情况，特别容易漏数。
在左边的1进入辅助数组后，2和1比较发现等于它的两倍，并不满足条件，而且右1小将进入辅助数组，这是4还没有和1比较，这种也是符合情况的，但是被直接跳过了。
面对上面这种情况，我开始想到的是如果左比右大但是没有两倍大，就左组最后一个去比较，然后从后遍历到没有两倍大的元素后面程序虽然没什么问题，但是在数据量大的时候容易出现问题，所以，我直接在合并前就统计好了。
public int reversePairs(int[] nums) {
if (nums == null || nums.length == 0){
return 0;
}
int l = 0;
int r = nums.length - 1;
int mid = l + ((r - l) >> 1);
sort(nums,l,mid) ;
sort(nums,mid + 1,r);
merge(nums,l,mid,r);
return sum;
}
public void sort(int[] arr,int l,int r){
if (l >= r){
return;
}
int mid = l + ((r - l)>>1);
sort(arr,l,mid) ;
sort(arr,mid + 1,r);
merge(arr,l,mid,r);
}
public void merge(int[] arr,int l,int mid,int r){
if (l >= r){
return;
}
int[] temp = new int[r - l + 1];
int i = l, j = mid + 1;
int index = 0;
//在进行统计前，遍历左子组，比较右子组完成统计筛选。
for (int index1 = l, index2 = mid + 1; index1 <= mid; index1++) {
//左子组的每个元素 和右子组比较 当未越界，还有满足两倍条件时 注意2L是为了超出int范围而导致的误差
while (index2 <= r && arr[index1] > 2L * arr[index2]) {
index2++;
}
sum += index2 - (mid + 1);
}
while (i <= mid && j <= r) {
temp[index++] = arr[i] > arr[j] ? arr[j++] : arr[i++];
}
while (i <= mid) {
temp[index++] = arr[i++];
}
while (j <= r) {
temp[index++] = arr[j++];
}
for (int k = 0; k < temp.length; k++) {
arr[l + k] = temp[k];
}
}
以上就是关于运用归并思想的题目.
268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
