第04节课
1. 归并排序
1.1 递归方式实现
思路:数组一分为二,先保证分别有序,然后再合并为有序数组,一直拆分,直到最多只有以个元素(一定有序)时再归并
代码:
// 递归方式
void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
process(arr, 0, arr.length - 1);
}
void process(int[] arr, int L, int R) {
if (L == R) {
return;
}
int mid = L + ((R - L) >> 1);
process(arr, L, mid);
process(arr, mid + 1, R);
merge(arr, L, mid, R);
}
void merge(int[] arr, int L, int M, int R) {
// 左边: [L, M] 右边: [M+1, R]
int[] help = new int[R - L + 1];
int i = 0;
int p1 = L;
int p2 = M + 1;
while (p1 <= M && p2 <= R) {
help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
}
// 要么p1越界了,要么p2越界了
while (p1 <= M) {
help[i++] = arr[p1++];
}
while (p2 <= R) {
help[i++] = arr[p2++];
}
// 拷回
for (i = 0; i < help.length; i++) {
arr[L + i] = help[i];
}
}
1.2 迭代方式实现
思路:设置步长依次为2的0.1.2.3次方,知道步长大于数组长度一般结束,每一次步长中都会将数组拆分为多个碎块,分别为左块和右块,进行归并,最终数组有序
// 迭代方式
void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int step = 1;
while (step <= arr.length) {
for (int i = 0; i < arr.length; i += step << 1) {
// 这里需要特别注意边界问题,R和M值都有越界风险
merge(arr, i, Math.min(i + step - 1, arr.length - 1), Math.min(i + 2 * step - 1, arr.length - 1));
}
step <<= 1;
}
}
void merge(int[] arr, int L, int M, int R) {
// 左边: [L, M] 右边: [M+1, R]
int[] help = new int[R - L + 1];
int i = 0;
int p1 = L;
int p2 = M + 1;
while (p1 <= M && p2 <= R) {
help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
}
// 要么p1越界了,要么p2越界了
while (p1 <= M) {
help[i++] = arr[p1++];
}
while (p2 <= R) {
help[i++] = arr[p2++];
}
// 拷回
for (i = 0; i < help.length; i++) {
arr[L + i] = help[i];
}
}
2. 数组小和问题
描述:在一个数组中,一个数左边比它小的数的总和,叫数的小和,所有数的小和累加起来,叫数组小和。求数组小和
例子: [1,3,4,2,5]
1左边比1小的数:没有
3左边比3小的数:1
4左边比4小的数:1、3
2左边比2小的数:1
5左边比5小的数:1、3、4、 2
所以数组的小和为1+1+3+1+1+3+4+2=16
思路:将问题看成求一个数的右边有多少个数比它大,则最终的小和中就有多少个该值的累加,采用递归方式求解。
代码:
public static long smallSum(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
return process(arr, 0, arr.length - 1);
}
private static long process(int[] arr, int L, int R) {
if (L == R) {
return 0;
}
int M = L + ((R - L) >> 1);
long leftRet = process(arr, L, M);
long rightRet = process(arr, M + 1, R);
long mergeRet = merge(arr, L, M, R);
return leftRet + rightRet + mergeRet;
}
private static long merge(int[] arr, int L, int M, int R) {
int[] help = new int[R - L + 1];
long ans = 0;
int ptr1 = L;
int ptr2 = M + 1;
int ptr = 0;
while (ptr1 <= M && ptr2 <= R) {
if (arr[ptr1] < arr[ptr2]) {
help[ptr++] = arr[ptr1];
ans += (long) arr[ptr1++] * (R - ptr2 + 1);
} else {
help[ptr++] = arr[ptr2++];
}
}
while (ptr1 <= M) {
help[ptr++] = arr[ptr1++];
}
while (ptr2 <= R) {
help[ptr++] = arr[ptr2++];
}
for (int i = 0; i < help.length; i++) {
arr[L + i] = help[i];
}
return ans;
}
3. 数组逆序对问题
描述:在一个数组中,任何一个前面的数a,和任何一个后面的数b,如果(a,b)是降序的,就称为逆序对,求数组中所有的逆序对
思路:使用归并排序思想实现
public static int revertPairCount(int[] arr) {
if (arr == null || arr.length < 2) {
return 0;
}
return process(arr, 0, arr.length - 1);
}
private static int process(int[] arr, int L, int R) {
if (L == R) {
return 0;
}
int M = L + ((R - L) >> 1);
int leftCount = process(arr, L, M);
int rightCount = process(arr, M + 1, R);
int mergeCount = merge(arr, L, M, R);
return leftCount + rightCount + mergeCount;
}
private static int merge(int[] arr, int L, int M, int R) {
int ans = 0;
int p1 = L;
int p2 = M + 1;
int p = 0;
int[] help = new int[R - L + 1];
while (p1 <= M && p2 <= R) {
if (arr[p1] > arr[p2]) {
help[p++] = arr[p2];
ans += M - p1 + 1;
p2++;
} else {
help[p++] = arr[p1++];
}
}
while (p1 <= M) {
help[p++] = arr[p1++];
}
while (p2 <= R) {
help[p++] = arr[p2++];
}
for (int i = 0; i < help.length; i++) {
arr[L + i] = help[i];
}
return ans;
}
4. 数组一个数右边数乘以2都比当前数小的总个数
在一个数组中,对于每个数num,求有多少个后面的数*2 依然小于num,求总个数
比如:[3, 1, 7, 0, 2]
3的后面有:1, 0
1的后面有:0
7的后面有:0, 2
0的后面没有
2的后面没有
所以总共有5个
思路:使用归并排序的思路,在合并的函数中找到answer值。
代码:
public static int biggerTwice(int[] arr) {
if (arr == null || arr.length < 2) {
return 0;
}
return process(arr, 0, arr.length - 1);
}
private static 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);
}
private static int merge(int[] arr, int L, int M, int R) {
int ans = 0;
int p1 = L;
int p2 = M + 1;
int p = 0;
int[] help = new int[R - L + 1];
// 计算 这里可以进一步优化,这种实现存在重复比较
int ptr = M + 1;
while(ptr <= R) {
for (int i = L; i <= M; i++) {
if(arr[ptr] * 2 < arr[i]) {
ans += M - i + 1;
break;
}
}
ptr++;
}
// 进行归并排序
while (p1 <= M && p2 <= R) {
help[p++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
}
while (p1 <= M) {
help[p++] = arr[p1++];
}
while (p2 <= R) {
help[p++] = arr[p2++];
}
for (int i = 0; i < help.length; i++) {
arr[L + i] = help[i];
}
return ans;
}