快排和并归排序的递归过程

快排：

public static void quickSort(int[] arr, int left, int right) {
        int l = left;//左下标
        int r = right;//右下标
        int temp = 0;//临时变量，交换时使用
        //pivot 中轴值
        int pivot = arr[(left + right) / 2];

        //while循环的目的是让比pivot值小的放到左边，大的放到右边
        while (l < r) {
            //在pivot左边一直找，直到找到大于等于pivot的值，再退出
            while (arr[l] < pivot) {
                l++;
            }
            //在pivot右边一直找，直到找到小于等于pivot的值，再退出
            while (arr[r] > pivot) {
                r--;
            }

            if (l >= r) {
                break;
            }

            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            if (arr[l] == pivot) {
                l++;
            }
            if (arr[r] == pivot) {
                r--;
            }
        }

        //如果l == r，必须l++, r--，否则栈溢出
        if (l == r) {
            l++;
            r--;
        }

        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }

        //向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }
    }

其局部递归过程为：

        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }

        //向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }

其细节为：当只要left索引小于r索引，就不断执行向左递归，不断进入向左递归的方法，直到向左递归的条件不满足时，会进行向右递归的判断。这时如果进入向右递归，则有可能又进入下一层的向左递归，如果不进入，则本层的quickSort方法执行结束，会退到上一层的向右递归前面，进行向右递归的判断。然后进入向右递归之后，也会重新进入下一层的向左递归。总之，快排的排序，会先排完原始数组左端，再排原始数组右端。对于每一次新进入的递归，也是先排左边，后排右边。最后把前一半原始数组排完后，才会排后一半原始数组。

并归排序：

import java.util.Arrays;

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


    }





    //分+合方法
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            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 做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left; //初始化i，左边有序序列的初始索引
        int j = mid + 1;
        int t = 0; //指向temp数组的当前索引

        //一
        //先把左右两边（有序）的数据按照规则填充到temp数组
        //直到两边的有序序列有一半处理完为止
        while (i <= mid && j <= right) {
            //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边的当前元素，拷贝到temp数组
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t++;
                i++;
            } else { //反之，将右边有序序列的当前元素，填充到temp数组
                temp[t] = arr[j];
                t++;
                j++;
            }
        }

        //二
        //把剩余数据的一边的数据一次全部填充到temp
        while (i <= mid) { //左边的有序序列还有剩余的元素
            temp[t] = arr[i];
            t++;
            i++;

        }

        while (j <= right) {
            temp[t] = arr[j];
            t++;
            j++;
        }

        //三
        //将temp数组的元素拷贝到arr
        //注意，并非每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }


    }
}

其局部递归过程为：

public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2; //中间索引
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            //向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);

        }
    }

对于并归排序，首先是进行分解。只要满足左递归分解的条件，就会不断执行左分解。左分解实质是不断重置了mid值，但各mid值在各层栈中已经保留。当最后不满足左递归分解的条件时，就会向下进行右递归分解的判断。最后左递归分解和右递归分解的进入条件均不满足，就会执行merge方法，同时本层的mergeSort方法执行完毕，退回上层mergeSort方法的向右递归语句前面，进入向右递归的语句进行分解操作。最终的顺序是：0-1，2-3都被分解完成，就会进入merge方法，把分解完的进行合并排序，同时本层方法执行结束，退回到上一层的向右递归分解语句前面。总之并归排序的执行顺序是：先分解原始数组最左端的元素，把分解的元素合并排序，再分解原始数组次左端的元素，再合并排序，从左到右依次进行。