归并排序

import java.util.Arrays;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {85, 4, 59, 17, 1, 3, 26, 2};
        int[] temp = new int[arr.length];
//        mergeSort(arr, 0, arr.length - 1, temp);
        mergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 归并排序(递归)
     *
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    private static void mergeSort(int[] arr, int left, int right, int[] temp) {
        // 先拆分
        if (left >= right) {
            return;
        }
        int mid = (left + right) / 2;// 中间索引
        // 向左拆分
        mergeSort(arr, left, mid, temp);
        //向右拆分
        mergeSort(arr, mid + 1, right, temp);
        // 合并
        merge(arr, left, mid, right, temp);

    }

    /**
     * @param arr   源数组
     * @param left  左边索引
     * @param mid   中间索引
     * @param right 右边索引
     * @param temp  临时数组
     */
    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int lp = left;// 左边的起始位置
        int rp = mid + 1;// 右边的起始位置
        int index = 0;// 临时数组的索引位置

        while (lp <= mid && rp <= right) {
            if (arr[lp] < arr[rp]) {
                temp[index++] = arr[lp++];
            } else {
                temp[index++] = arr[rp++];
            }
        }
        // 将左边数组剩余部分直接添加到临时数组
        while (lp <= mid) {
            temp[index++] = arr[lp++];
        }
        // 将右边数组剩余部分直接添加到临时数组
        while (rp <= right) {
            temp[index++] = arr[rp++];
        }
        // 将排好序的数组的数据重新填充到arr中(不是每次合并都合并所有元素,临时数组中有几个元素就填充几个元素)
        int temRp = right;
        while (index > 0) {
            arr[temRp--] = temp[--index];
        }
    }

    /**
     * 归并排序(非递归)
     *
     * @param arr
     */
    public static void mergeSort(int[] arr) {
        int len = arr.length;
        int[] temp = new int[len];
        int block, start;
        for (block = 1; block < len * 2; block *= 2) {
            for (start = 0; start < len; start += 2 * block) {
                int left = start;
                int mid = start + block < len ? start + block : len;
                int right = start + 2 * block < len ? start + 2 * block : len;
                int start1 = left, end1 = mid;
                int start2 = mid, end2 = right;
                // 进行合并
                while (start1 < end1 && start2 < end2) {
                    temp[left++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
                }
                // 如果块中有剩余元素直接填充到临时数组后面
                while (start1 < end1) {
                    temp[left++] =arr[start1++];
                }
                while (start2 < end2) {
                    temp[left++] =arr[start2++];
                }
            }
            // 此时temp是已经排序好的数组
            int[] arr2 = arr;
            arr = temp;
            temp = arr2;
        }
    }
}