归并排序及其扩展算法题

归并排序代码

/**
 * @author IT00ZYQ
 * @date 2021/4/22 21:40
 **/
public class 归并排序及扩展 {

    /**
     * 递归 归并排序
     * @param nums
     */
    public static void mergeSort(int[] nums) {
        mergeSort(nums, 0, nums.length - 1);
    }

    /**
     * 把[l, r]变成有序
     * @param nums
     * @param l
     * @param r
     */
    private static void mergeSort(int[] nums, int l, int r) {
        if (l == r) {
            return;
        }
        int mid = l + ((r-l) >> 1);
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        merge(nums, l, r, mid);
    }

    /**
     * 非递归 归并排序
     * @param nums
     */
    public static void mergeSort2(int[] nums) {
        // 步长从1开始增长，每次剩2，直至步长大于数组长度，则排序完成
        int step = 1;
        while (step < nums.length) {
            for (int i = 0; i < nums.length && i+step < nums.length; i += 2*step) {
                merge(nums, i, Math.min(i + 2*step - 1, nums.length-1), i + step - 1);
            }
            // 防止溢出
            if (step > nums.length/2) {
                break;
            }
            // 步长×2
            step <<= 1;
        }
    }

    private static void merge(int[] nums, int l, int r, int mid) {
        int[] help = new int[r-l+1];
        for (int i = l; i <= r; i++) {
            help[i-l] = nums[i];
        }

        int left = l;
        int right = mid + 1;
        int index = l;
        // 左指针与右指针都不越界，nums数组取较小的值
        while (left <= mid && right <= r) {
            if (help[left - l] <= help[right - l]) {
                nums[index] = help[left-l];
                left ++;
            } else {
                nums[index] = help[right-l];
                right ++;
            }
            index ++;
        }
        // 将左数组中未越界的数依次拷贝到nums
        while (left <= mid) {
            nums[index++] = help[left-l];
            left ++;
        }
        // 将右数组中未越界的数依次拷贝到nums
        while (right <= r) {
            nums[index++] = help[right-l];
            right ++;
        }
    }
}

扩展题：求较小和

/**
* 利用归并排序实现较小数之和
* [3, 1, 0, 9, 2, 4, 0]
* 比3小的数之和 0
* 比1小的数之和 0
* 比0小的数之和 0
* 比9小的数之和 3+1+0 = 4
* 比2小的数之和 1+0 = 1
* 比4小的数之和 3+1+0+2 = 6
* 较小数之和 4+1+6=11
*/
public static int minSum(int[] nums, int l, int r) {
   if (l == r) {
       return 0;
   }
   int mid = l + ((r-l) >> 1);
   return minSum(nums, l, mid) +
           minSum(nums, mid+1, r) +
           minSumMerge(nums, l, r, mid);

}

public static int minSumMerge(int[] nums, int l, int r, int mid) {
   int[] help = new int[r-l+1];
   for (int i = l; i <= r; i++) {
       help[i-l] = nums[i];
   }

   int ans = 0;

   int left = l;
   int right = mid + 1;
   int index = l;
   while (left <= mid && right <= r) {
       if (help[left-l] < help[right-l]) {
           nums[index++] = help[left-l];
           ans += help[left-l] * (r-right+1);
           left ++;
       } else {
           nums[index++] = help[right-l];
           right ++;
       }
   }

   while (left <= mid) {
       nums[index++] = help[left-l];
       left ++;
   }

   while (right <= r) {
       nums[index++] = help[right-l];
       right ++;
   }

   return ans;
}

扩展题：逆序对

/**
 * 利用归并排序求逆序对数
 * @param nums
 * @return
 */
public static int niXuDui(int[] nums, int l, int r) {
    if (l == r) {
        return 0;
    }
    int mid = l + ((r-l) >> 1);
    return niXuDui(nums, l, mid) +
            niXuDui(nums, mid + 1, r) +
            niXuDuiMerge(nums, l, r, mid);
}

public static int niXuDuiMerge(int[] nums, int l, int r, int mid) {
    int[] help = new int[r-l+1];
    for (int i = l; i <= r; i++) {
        help[i-l] = nums[i];
    }

    int ans = 0;
    int left = mid;
    int right = r;
    int index = r;
    while (left >= l && right > mid) {
        if (help[right - l] < help[left - l]) {
            ans += left - l + 1;
            nums[index--] = help[right - l];
            right --;
        } else {
            nums[index--] = help[left - l];
            left --;
        }
    }

    while (left >= l) {
        nums[index--] = help[left - l];
        left --;
    }

    while (right > mid) {
        nums[index--] = help[right - l];
        right --;
    }

    return ans;
}