算法与数据结构 归并排序

1. 归并排序

归并排序是与插入排序、交换排序、选择排序不同的另一类排序方法。归并的含义是将两个或者两个以上的有序表合成一个新的有序表。

• 二路归并排序：将两个有序表合成一个的归并叫二路归并排序

归并排序既可以用于内部排序，也可以用于外部排序。
二路归并的思想是将待排序记录r[0] 到r[n - 1] 看成一个含有 n 个长度为 1 的有序子表，把这些子表依次进行两两归并，得到 [ n / 2 ] 个有序的子表；再把这[n / 2] 个有序的子表进行两两归并，重复，直到得到一个长度为 n 的有序表为止。

二路归并的核心操作是两个相邻的有序序列归并为一个有序序列。

 int[] arr = new int[20];
        Random random = new Random();
        for (int i = 0;i < arr.length; i++) {
            arr[i] = random.nextInt(50);
        }
        mergingsort(arr,0,arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
    private static void mergingsort(int[] arr, int l, int r) {
        if (l >= r){
            return ;
        }
        // 归
        int mid = (l + r) / 2;
        mergingsort(arr,l,mid);
        mergingsort(arr,mid + 1,r);
        //并
        merge(arr,l,mid,r);
    }
    private static void merge(int[] arr, int l, int mid, int r) {
        int[] aux = new int[r - l + 1];
        for (int i = l;i <= r;i++) {
            aux[i - l] = arr[i];
        }
        int i = l;
        int j = mid + 1;
        for (int k = l;k <= r;k++) {
            if (i > mid) {
                arr[k] = aux[j - l];
                j++;
            } else if (j > r) {
                arr[k] = aux[i - l];
                i++;
            }else if (aux[i - l] < aux[j - l]) {
                arr[k] = aux[i - l];
                i++;
            }else {
                 arr[k] = aux[j - l];
                 j++;
            }
        }
//输出结果
[3, 4, 5, 9, 13, 14, 15, 16, 21, 24, 26, 28, 28, 28, 33, 33, 43, 43, 45, 48]

import java.util.Arrays;

//归并排序
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {7, 1, 6, 2, 8, 4, 5, 3};
        mergeSort(arr,0,arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    // 递归使用归并排序，对arr[l...r]的范围进行排序
    private static void mergeSort(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        /*
        // 2.优化改进：当范围较小时，可用插入排序
        if (r - l <= 15) {
            InsertionSort.insertionSort(arr, l, r);
            return;
        }
         */

        int mid = (l + r) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);

        merge(arr, l, mid, r);

        /*
        // 1.优化改进：已经左小右大不需归并
        if (arr[mid] > arr[mid + 1]) {
            merge(arr, l, mid, r);
        }
        */
    }

    // 将arr[l...mid]和arr[mid+1...r]两部分进行归并
    private static void merge(int[] arr, int l, int mid, int r) {
        int[] aux = new int[r - l + 1];
        for (int i = l; i <= r; i++) {
            aux[i - l] = arr[i];
        }
        int i = l, j = mid + 1;
        for (int k = l; k <= r; k++) {
            if (i > mid) {
                arr[k] = aux[j - l];
                j++;
            } else if (j > r) {
                arr[k] = aux[i - l];
                i++;
            } else if (aux[i - l] < aux[j - l]) {
                arr[k] = aux[i - l];
                i++;
            } else {
                arr[k] = aux[j - l];
                j++;
            }
        }
    }
}