小数和问题
描述
在一个数组中，一个数左边比它小的数的总和，叫数的小和，所有数的小和累加起来，叫数组小和。求数组小和。例子
5 2 6 1 7
小和原始的求法是：任何一个数左边比它小的数累加起来。
5左边比它小数累加：0
2左边比它小数累加：0
6左边比它小数累加：5 + 2 = 7
1左边比它小数累加：0
7左边比它小数累加：5 + 2 + 6 + 1 = 14
总共21。思路
如果左侧某数a比右侧某数b小，则在求b的小和的时候，肯定会累加一个a，即sum+=a。
反过来，在遍历到a的时候，如果我们知道右侧有几个数比a大，则可以提前知道会累加几个a
使用归并排序时恰好有左右对比操作，所以使用归并排序来做
即：
每个数右边比它大的数的个数 * 这个数自身
所以：
在原来归并排序的基础上，增加一个ans用于记录结果
在进行归并时左侧<右侧时产生小数 n * number小和求法还可以是：每个数右边比它大的数的个数 * 这个数自身
5 2 6 1 7
5的右边比它大的数的个数：2个（6和7），所以产生：2个 * 5 = 10
2的右边比它大的数的个数：2个（6和7），所以产生：2个 * 2 = 4
6的右边比它大的数的个数：1个（7），所以产生：1个 * 6 = 6
1的右边比它大的数的个数：1个（7），所以产生：1个 * 1 = 1
7的右边比它大的数的个数：0个，所以产生：0个 * 7 = 0
总共21。code
非递归
java
public static int smallSum(int [] arr){
if(arr == null || arr.length <2)
return 0;
int [] help = new int[arr.length];
int step = 1;
int N = arr.length;
int L = 0;
int ans = 0;
while (step < N){
L = 0;
while (L < N){
//左组最后一个数位置
int m = L + step - 1;
if(m >= N){
break;
}
if(step >= N - L){
break;
}
int R = Math.min(m+step,N-1);
ans += merge(arr,L,m,R,help);
L = R + 1;
}
if(step > N/2){
break;
}
step <<= 1;
}
return ans;
}
public static int merge(int[] arr,int l,int m,int r,int [] help){
//help index
int i = 0;
//p1 左侧开始index,p2 右侧开始index
int p1 = l;
int p2 = m+1;
//结果保存
int ans = 0;
while (p1 <= m && p2 <= r){
ans += arr[p1]<arr[p2]?arr[p1] *(r-p2+1):0;
help[i++] = arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
}
while (p1 <= m){
help[i++] = arr[p1++];
}
while (p2 <= r){
help[i++] = arr[p2++];
}
for (i = 0; i < r-l+1 ; i++) {
arr[l+i] = help[i];
}
return ans;
}递归
java
public static int progress(int [] arr,int l,int r,int [] help){
if(l == r)
return 0;
int m = l + ((r -l) >> 1);
return progress(arr,l,m,help)
+ progress(arr,m+1,r,help)
+ merge(arr,l,m,r,help);
}逆序对问题
描述
一个数组中，左边的数比右边的数大，求有多少个这样的组合比如 [3,1,0,4,3,1] 有7个逆序对，分别是
(3,1),(3,0),(3,1)
(1,0)
(4,3),(4,1)
(3,1)
code
java
//递归
public static int reversePair(int [] arr){
if(arr == null || arr.length <2)return 0;
return progress(arr,0,arr.length -1);
}
public static int progress(int [] arr,int l,int r){
if(l == r)return 0;
int m = l + ((r-l)>>1);
return progress(arr,l,m)
+progress(arr,m+1,r)
+merge(arr,l,m,r);
}
//非递归
public static int reversePair2(int [] arr){
if(arr == null || arr.length < 2)return 0;
int ans = 0;
int L = 0;
int N = arr.length;
int step = 1;
while (step < N){
L = 0;
while (L < N){
if(L+step >= N)break;
int m = L + step - 1;
if(m >= N)break;
int r = Math.min(N-1,m+step);
int temp = merge(arr,L,m,r);
ans += temp;
L = r + 1;
}
if(step > N/2)break;
step <<= 1;
}
return ans;
}
public static int merge(int [] arr,int L,int M,int R){
// 先算有多少逆序对
// 和归并过程分离
int res = 0;
int p = M + 1;
for (int i = L; i <= M; i++) {
while (p <= R && arr[i] > arr[p]) {
p++;
}
res += p - (M + 1);
}
// 下面完全和归并排序一样
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];
}
return res;
}左边大于右边倍数的数
描述
在一个数组中，
对于每个数num，求有多少个后面的数 * 2 依然<num，求总个数
比如：[3,1,7,0,2]
3的后面有：1，0
1的后面有：0
7的后面有：0，2
0的后面没有
2的后面没有
所以总共有5个思路
右边有多少个数*2比左边的数小
在归并排序过程中，分组后左侧有序，右侧有序，在进行左右侧合并时，统计验证关系【2倍关系】
这样可以得到该左侧位置相对于右侧位置的2倍关系统计和code
java
//递归
public static int biggerThatRightTwice(int []arr){
if(arr == null || arr.length<2){
return 0;
}
return progress(arr,0,arr.length-1);
}
public static int progress(int[] arr,int l,int r){
if(l == r){
return 0;
}
int m = l + ((r-l)>>1);
System.out.println("l,m,r:"+l+","+m+","+r);
return progress(arr,l,m)
+progress(arr,m+1,r)
+merge(arr,l,m,r);
}
//非递归
public static int biggerThatRightTwice2(int [] arr){
if(arr == null || arr.length <2)return 0;
int L = 0;
int step = 1;
int N = arr.length;
int ans = 0;
while (step < N){
L = 0;
while (L < N){
if(step >= N-L)break;
int m = L + step - 1;
if(m >= N)break;
int r = Math.min(m+step,N-1);
ans += merge(arr,L,m,r);
L = r + 1;
}
if(step > N/2)break;
step <<=1;
}
return ans;
}
public static int merge(int[] arr,int l,int m,int r){
//[l,m] [m+1,r]进行归并，其中[l,m],[m+1,r]分别已经有序
//先计算
int p1 = l,p2 = m+1;
int ans = 0;
//左侧遍历l
while (p1 <= m){
//右侧遍历
while (p2 <= r){
//如果左侧 > 右侧 * 2，则继续判断，知道不满足条件
//当不满足条件时，则右侧从开始位置m+1到p2位置为p1满足条件的数
if(arr[p1] > arr[p2] *2){
p2++;
}else{
break;
}
}
//p2 - (m+1) => [m+1,p2) 即从m+1到p2个元素个数，不包含p2
ans += (p2 - (m+1));
p1++;
}
//再进行归并
int [] help = new int[r-l+1];
int i = 0;
p1 = l;
p2 = m+1;
while (p1<=m && p2<=r){
help[i++] = arr[p1]<arr[p2]?arr[p1++]:arr[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];
}
return ans;
}