算法：归并排序和快排的区别

一，二者比较

归并排序和快排的相同点：

1，利用分治思想
2，具体实现都用递归

归并排序和快排的不同点：

1，先分解再合并：归并排序先递归分解到最小粒度，然后从小粒度开始合并排序，自下而上的合并排序；
2，边分解边排序：快速排序每次分解都实现整体上有序，即参照值左侧的数都小于参照值，右侧的大于参照值；是自上而下的排序；
3，归并排序不是原地排序，因为两个有序数组的合并一定需要额外的空间协助才能合并；
4，快速排序是原地排序，原地排序指的是空间复杂度为O(1)；
5，归并排序每次将数组一分为二，快排每次将数组一分为三

二，快排的实现

原理：

• 在数组中选取一个参照值，如下图的最后一个元素，将比这个值大的元素都转移到数组左侧，比这个值大的转移到数组右侧。

• 此时数组分为三个部分，将左侧数组和右侧数组作为新数组按照上面的思路进行递归。

实现快排的三步：

1，分区：将比参照值小的移动到参照值的左侧，比参照值大的移动到右侧；

2，左递归：对左侧数组进行递归；

3，右递归：对右侧数组进行递归；

关键在于分区的实现：

• 如果不要求空间复杂度是常数，则非常简单，创建两个数组，分别存放左侧数组和右侧数组，然后把左侧数组、参照值、右侧数组合并为一个数组，替代原数组；

• 如果要求空间复杂度是O(1)，则算法复杂一些，完整代码如下：

public static void main(String[] args) {
        int[] arr = new int[]{1,4,3,7,5};
        quickSort(arr,0,arr.length-1);

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
    private static void quickSort(int[] arr, int start, int end) {
        if (start >= end) {
            return;
        }
        // 分区
        int middleIndex = partition(arr,start,end);
        // 左侧数组递归快排
        quickSort(arr,start,middleIndex-1);
        // 右侧数组递归快排
        quickSort(arr,middleIndex+1,end);

    }

   // 分区的算法空间复杂度是O(1)
    private static int partition(int[] arr, int start, int end) {
        int slow = start,fast = start;
        int value = arr[end];

        for (;fast<=end;fast++) {
               if (arr[fast] < value) {
                   int temp = arr[fast];
                   arr[fast] = arr[slow];
                   arr[slow] = temp;

                   slow++;
               }
        }

        arr[end] = arr[slow];
        arr[slow] = value;

        return slow;
    }

对于上述分区算法理解的关键点：

1，快慢指针；
2，选取数组最后一个元素作为参照值；
3，如果快指针对应的值小于参照值，则快慢指针对应的值交换，快慢指针同时前进；
4，如果快指针对应的值大于参照值，快指针前进，慢指针原地不动；
5，慢指针的最后位置与参照值进行交互，并将该位置返回，作为将数组切分为2的依据；

问题：

当数组本身是有序数组时，所有交换都是无效交换，可以想办法优化，不做无用的交换。

分区原理图：

三，归并排序

原理：

• 将一个数组从中间一分为二，形成左右两个数组
• 对左右两个数组继续按照第一步的方式递归的一分为二，直到数组只有一个元素为止
• 对数组进行合并，合并时进行排序

原理图：

代码：

private static int[] mergeSort(int[] arr, int start, int end) {
        if (start == end) {
            return new int[]{arr[start]};
        }

        int middle = (start+end)/2;
        int[] arrLeft = mergeSort(arr,start,middle);
        int[] arrRight = mergeSort(arr,middle+1,end);

        return merge(arrLeft,arrRight);
        
    }

    // 合并两个数组成为有序数组
    private static int[] merge(int[] arrLeft, int[] arrRight) {
        int i=0,j=0,newArrIndex=0;
        int[] newArr = new int[arrLeft.length+arrRight.length];

        for(;i<arrLeft.length&&j<arrRight.length;) {
            if (arrLeft[i] < arrRight[j]) {
                newArr[newArrIndex++] = arrLeft[i];
                i++;
            }else {
                newArr[newArrIndex++] = arrRight[j];
                j++;
            }
        }

        if (i < arrLeft.length -1) {
            while (i <= arrLeft.length-1) {
                newArr[newArrIndex++]=arrLeft[i++];
            }
        }

        if (j < arrRight.length -1) {
            while (j <= arrRight.length-1) {
                newArr[newArrIndex++]=arrRight[j++];
            }
        }

        return newArr;
    }