算法笔记-第04节课

第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;
}