归并排序

package mergesort;

import java.util.Arrays;

public class MergeSort {

    public static void main(String[] args) {

    	int[] arr = new int[] {9,6,8,4,2,10,1};

        mergeSort(arr, 0, arr.length-1);

        System.out.println(Arrays.toString(arr));
    }

    /**
     * 归并排序
     * 思想：分而治之
     * 时间复杂度O(n * log(n))
     * 稳定的排序
     *
     * @return 返回排序后的数组
     */
    public static void mergeSort(int[] arr, int left, int right) {
    	// 注意：这里可不能写成left > right,，因为下面涉及到了/2的事情，如果是写成这样的话那就说明left==right的时候是可以继续递归的
    	// 这样就造成了center = (left + right)/2结果和left和right相等，那么下一次还是能够继续递归，永远不会出现left>right的情况，这样就无限递归下去了
    	if (left >= right) {
        	return;
        }
            //数组拆分（分而治之中的 “分”）
            int center = (left + right) / 2;
            // 递归调用
            // 子过程要求从left到center排好序，从center+1到right排好序
            mergeSort(arr, left, center);
            mergeSort(arr, center + 1, right);

            //当问题拆到不能再拆的时候，开始合并（分而治之中的 “治”） 
            merge(arr, left, right);

    }

    public static void merge(int[] arr, int left, int right) {
        int[] temp = new int[right - left + 1];

        int mid = (left + right) / 2;
        // i指针指向左半部分的最小值，j指针指向右半部分的最小值 
        int i = left;
        int j = mid+1;
        int t = 0;
        //逐一比较大小，谁更小就把谁填入到临时的数组中，循环跳出的条件是一旦有一个数组耗尽了
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        
        // 当上面的那个while循环执行完了以后，肯定i和j中有一个已经是越界了，这时候我们要把没有越界的那个数组剩下的元素全都拷贝进临时数组即可
        // 所以说虽然这两个while是顺序执行的，但是肯定只能执行一个，因为i和j一定有一个是已经越界了
        while (i <= mid) {
            temp[t++] = arr[i++];
        }
        while (j <= right) {
            temp[t++] = arr[j++];
        }

        //把临时数组的内容拷贝回去
        for(int k = 0; k<temp.length; k++) {
        	arr[left + k] = temp[k];
        }
    }
}

注意：归并排序，归：即递归，并：即合并。他们之间在逻辑上相互独立的。在理解的时候不能混为一谈。

递归只是一种思想，即我现在要把大的数组排序，那我可以把它分成子问题，也就是我把小数组排好序，小数组的排序我让我的子过程去做，当我的子过程分到不能再分的时候，我再去合并（注意：合并这里才是排序的核心，递归的部分并没有涉及到任何的排序的东西，它只是在把问题划分成子问题），归并排序的思想叫做分治思想，这里递归的过程就叫做“分”，当分到不能再分的时候，开始合并。合并的过程叫做“治”。