算法体系-05 第五 归并排序及其相关

一归并排序

1.1 分析

1）整体是递归，左边排好序+右边排好序+merge让整体有序

2）让其整体有序的过程里用了排外序方法

3）利用master公式来求解时间复杂度

4）当然可以用非递归实现

1.2 递归实现归并排序

1.2.1 分析

1.2.2 代码

// 递归方法实现
public static void mergeSort1(int[] arr) {
   if (arr == null || arr.length < 2) {
      return;
   }
   process(arr, 0, arr.length - 1);
}

// 请把arr[L..R]排有序
// l...r N
// T(N) = 2 * T(N / 2) + O(N)
// O(N * logN)
public static void process(int[] arr, int L, int R) {
   if (L == R) { // base case
      return;
   }
   int mid = L + ((R - L) >> 1);
   process(arr, L, mid);
   process(arr, mid + 1, R);
   merge(arr, L, mid, R);
}

public static void merge(int[] arr, int L, int M, int 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];
   }
}

下边是将左边中间再右边分为了数组，上边是还没分是原始是的l到r到r

1.3 迭代实现归并排序

1.3.1 分析

1.3.2 代码

分析 第一步是计算步长，根据步长计算左右要合并的index，

// 非递归方法实现
public static void mergeSort2(int[] arr) {
   if (arr == null || arr.length < 2) {
      return;
   }
   int N = arr.length;
   // 步长
   int mergeSize = 1;
   while (mergeSize < N) { // log N
      // 当前左组的，第一个位置
      int L = 0;
      while (L < N) {
          //当要到最右边的时候，L加上mergeSize长度超出数组的长度就跳出这个循环
         if (mergeSize >= N - L) {
            break;
         }
         int M = L + mergeSize - 1;
         int R = M + Math.min(mergeSize, N - M - 1);
         merge(arr, L, M, R);
         L = R + 1;
      }
      // 防止溢出
      if (mergeSize > N / 2) {
         break;
      }
      mergeSize <<= 1;
   }
}

// for test
public static int[] generateRandomArray(int maxSize, int maxValue) {
   int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
   for (int i = 0; i < arr.length; i++) {
      arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
   }
   return arr;
}

二 小和问题

2.0 题目描述

每个数左边的数累加起来，整体再算一个总的累加和；

在一个数组中，一个数左边比它小的数的总和，叫数的小和，所有数的小和累加起来，叫数组小和。求数组小和。

例子： [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

2.1 思路分析

左边有多小个比自己小的就全部加起来，等价于当前数右边有多少个比自己大的就有多少个自己相加的和，在合并的过程中，只需要找右边比自己大的个数就行，因为在合并的过程中左组（当前组）在上一次合并的过层中就已经计算过了，所以在当前合并就不需要再计算当前组的了；

相等的时候先拷贝右边的；因为需要找到右边比他大的

相等的还是先拷贝右边的

2.2 代码

public static int smallSum(int[] arr) {
   if (arr == null || arr.length < 2) {
      return 0;
   }
   return process(arr, 0, arr.length - 1);
}

// arr[L..R]既要排好序，也要求小和返回
// 所有merge时，产生的小和，累加
// 左 排序   merge
// 右 排序  merge
// merge
public static int process(
int[] arr, int l, int r) {
   if (l == r) {
      return 0;
   }
   // l < r
   int mid = l + ((r - l) >> 1);
   //这里加是因为当前遍历道相等的时候返回return 0; 
   return 
         process(arr, l, mid) 
         + 
         process(arr, mid + 1, r) 
         + 
         merge(arr, l, mid, r);
}

public static int merge(int[] arr, int L, int m, int r) {
   
 int[] help = new int[r - L + 1];
   int i = 0;
   int p1 = L;
   int p2 = m + 1;
   int res = 0;  
 while (p1 <= m && p2 <= r) {
 
      res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 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 < help.length; i++) {
      arr[L + i] = help[i];
   }
   return res;
}

// for test
public static int comparator(int[] arr) {
   if (arr == null || arr.length < 2) {
      return 0;
   }
   int res = 0;
   for (int i = 1; i < arr.length; i++) {
      for (int j = 0; j < i; j++) {
         res += arr[j] < arr[i] ? arr[j] : 0;
      }
   }
   return res;
}

三 逆序对

3.0 描述

在一个数组中，

任何一个前面的数a，和任何一个后面的数b，

如果(a,b)是降序的，就称为逆序对

返回数组中所有的逆序对

3.1 分析

拷贝的时候从右往左拷贝，当左边有一个比自己大的就算右边还没拷贝的个数，当相等的时候先拷贝右边；相等的时候先拷贝右边的

3.2 代码

public static int reverPairNumber(int[] arr) {
   if (arr == null || arr.length < 2) {
      return 0;
   }
   return process(arr, 0, arr.length - 1);
}

// arr[L..R]既要排好序，也要求逆序对数量返回
// 所有merge时，产生的逆序对数量，累加，返回
// 左 排序 merge并产生逆序对数量
// 右 排序 merge并产生逆序对数量
public static int process(int[] arr, int l, int r) {
   if (l == r) {
      return 0;
   }
   // l < r
   int mid = l + ((r - l) >> 1);
   return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
}

public static int merge(int[] arr, int L, int m, int r) {
   int[] help = new int[r - L + 1];
   int i = help.length - 1;
   int p1 = m;
   int p2 = r;
   int res = 0;
   //     找到p1和p2的关键起点，判断p1和p2的有效条件
   while (p1 >= L && p2 > m) {
       //两边都是有序的，当右边找到一个p2比左边p1小的时候，那么右边到p2到数组开位置都比比边p1小
      res += arr[p1] > arr[p2] ? (p2 - m) : 0;
      help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
   }
   while (p1 >= L) {
      help[i--] = arr[p1--];
   }
   while (p2 > m) {
      help[i--] = arr[p2--];
   }
   for (i = 0; i < help.length; i++) {
      arr[L + i] = help[i];
   }
   return res;
}

四 BiggerThanRightTwice

4.0 描述

number 的右边有多少个数* 2 依然小于 num 使用不回退的技巧

在一个数组中，

对于每个数num，求有多少个后面的数 * 2 依然

比如：[3,1,7,0,2]

3的后面有：1，0

1的后面有：0

7的后面有：0，2

0的后面没有

2的后面没有

所以总共有5个

4.1 分析

4.2 代码

public static int reversePairs(int[] arr) {
   if (arr == null || arr.length < 2) {
      return 0;
   }
   return process(arr, 0, arr.length - 1);
}

public static int process(int[] arr, int l, int r) {
   if (l == r) {
      return 0;
   }
   // l < r
   int mid = l + ((r - l) >> 1);
   return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
}

public static int merge(int[] arr, int L, int m, int r) {
   // [L....M] [M+1....R]
   int ans = 0;
   //前后都是排序好的，只知道是从小到大，到是确定不了某个大于 2*windowR数后边的都比他大，所以需要在这里提出来单独处理
   // 目前囊括进来的数，是从[M+1, windowR)
   int windowR = m + 1;
   for (int i = L; i <= m; i++) {
      while (windowR <= r && (long) arr[i] > (long) arr[windowR] * 2) {
         windowR++;
      }
      ans += windowR - 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++];
   }
   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;
}

五 跳表

面试官：讲讲 Zset 底层数据原理？为什么不用树而用跳表|Redis 面试_哔哩哔哩_bilibili