归并排序

归并排序是什么

归并排序之递归版

package Sort.MergeSort;

import Sort.SortTestHelper;

import java.util.Arrays;

/**
 * 在这里编写类的功能描述
 *
 * @author wangkai
 * @created 2020/2/8
 */
public class MergeSort {

    private MergeSort() {
    }

    public static void sort(Comparable[] arr) {

        sort(arr, 0, arr.length - 1);
    }

    public static void sort(Comparable[] arr, int l, int r) {

        if (l >= r)
            return;

        int mid = (r + l) / 2;
        sort(arr, l, mid);
        sort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    public static void merge(Comparable[] arr, int l, int mid, int r) {

        Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);

        //初始化，i指向左半部分起始位置，j指向右半部分起始位置
        int i = l;
        int j = mid + 1;

        //遍历数组[l,r],看每个位置适合放什么元素
        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].compareTo(aux[j - l]) <= 0) {//左半部分元素<=右半部分元素 =决定归并排序算法的稳定与否
                arr[k] = aux[i - l];
                i++;
            } else {  //左半部分元素>右半部分元素
                arr[k] = aux[j - l];
                j++;
            }

        }

    }

    public static void main(String[] args) {

        Integer[] arr = {49, 22, 65, 97, 76, 22, 27, 14, 10};
        SortTestHelper.testSort("Sort.MergeSort.MergeSort", arr);
        System.out.println(Arrays.toString(arr));

    }
}

归并排序之迭代法

package Sort.MergeSort;

import Sort.SortTestHelper;

import java.util.Arrays;

/**
 * 归并排序
 *
 * @author wangkai
 * @created 2020/2/8
 */
public class MergeSortBU {


    private MergeSortBU() {
    }

    public static void sort(Comparable[] arr) {

        //n指代的是长度，不是索引值
        int n = arr.length;

        for (int sz = 1; sz < n; sz = sz * 2) {
            //i+sz-1<n-1 可以进行的边界条件
            for (int i = 0; i < n - sz; i += sz * 2) {

                merge(arr, i, i + sz - 1, Math.min(i + sz * 2 - 1, n - 1));
            }
        }

    }

    public static void merge(Comparable[] arr, int l, int mid, int r) {


        Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);
        //初始化，i指向左半部分起始位置，j指向右半部分起始位置
        int i = l;
        int j = mid + 1;
        //遍历数组[l,r],看每个位置适合放什么元素
        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].compareTo(aux[j - l]) <= 0) { //左半部分元素<=右半部分元素 =决定归并排序算法的稳定与否

                arr[k] = aux[i - l];
                i++;
            } else { //左半部分元素>右半部分元素
                arr[k] = aux[j - l];
                j++;
            }
        }

    }

    public static void main(String[] args) {

        Integer[] arr = {49, 22, 65, 97, 76, 22, 27, 14, 10, 99, 99, 99};
        SortTestHelper.testSort("Sort.MergeSort.MergeSortBU", arr);
        System.out.println(Arrays.toString(arr));

    }
}

来源：CSDN

作者：凯凯王的技术生涯

链接：https://blog.csdn.net/qq_23864697/article/details/104218871