归并排序和快速排序Java实现与深度对比

《算法》第四版上说明：递归排序和快速排序都体现了分治的思想。不过归并的计算主要消耗在子向量的归并操作上，而快速排序却相反。
本篇文章用Java给出代码后再进行深度对比

快速排序

首先给出思路伪代码：

void quick_sort(⼀个数组) {
     if (可以很容易处理) *用插入排序;
     quick_sort(左半个数组);
     quick_sort(右半个数组);
     partition(左半个数组, 右半个数组);
}

具体实现（可跑IDE测试）

public class QuickSort{
    //先找切分左右子序列的index,将它的初始位置优化
    //好处是：序列里随机分布的大量重复元素可不必重新递归调用
    public static void quickSort(int[] arr,int lo ,int hi){
        if(lo<hi) {
            int index = partition(arr, lo, hi);
            quickSort(arr, lo, index - 1);
            quickSort(arr, index + 1, hi);
        }
    }
    //先通过partition方法将切分元素index的左右子序列进行排序
    public static int partition(int[] arr,int lo,int hi){
        //取左位为基准元素,则先从右边开始对比
        int key=arr[lo];
        //这里不用交换直接赋值
        while(lo<hi){
            //从序列右端开始，向左遍历，直到找到小于base的数
            while(arr[hi]>=key && hi>lo){ hi--; }
            arr[lo]=arr[hi]; //找到了比base小的元素，放到最左边
            //从序列左端开始，向右遍历，直到找到大于base的数
            while(arr[lo]<=key && hi>lo){ lo++; }
            arr[hi]=arr[lo]; //找到了比base大的元素，放到最右边
        }
        arr[lo]=key;//将备份的切分元素放回左右子序列之间
        return lo; // 此时lo=hi，切分元素给arr[lo]和arr[hi]一样
    }

    public static void main(String[] args) {
        int[] arr = new int[50];
        for (int i = 49; i >=0; i++) {
            arr[i] = i;
            quickSort(arr,0,arr.length);
        }
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

归并排序

首先给出思路伪代码：

void merge_sort(⼀个数组) {
     if (可以很容易处理) return;
     merge_sort(左半个数组);
     merge_sort(右半个数组);
     merge(左半个数组, 右半个数组);
}

具体实现（可跑IDE测试）：

public class MergeSort {
    public static void mergeSort(int[] arr){
    //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        int []temp = new int[arr.length];
        sort(arr,0,arr.length-1,temp);
    }
    private static void sort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        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<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;//指针回到临时数组首位
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        mergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

归并和快排的递归方法思路唯一区别是:归并是先递归再排序。快排先排序在切分递归。

两种排序的比较

• 相同点：相较于其它初级排序，这两种排序都是用切分而非直接遍历
• 不同点：
  （1）归并排序是渐进最优。保证最坏情况是O(nlgn),这是其它排序做不到的。局限在于空间是O(n)，并非原地排序。
  (2) 快速排序对于常规的随机分布序列很适合。大部分情况都是O(nlogn),空间上只是O(logn)。但它是不稳定排序。包含重复元素时，用三路切分来优化复杂度

如果对你有帮助的话来个赞呗，如果有什么问题欢迎交流，我会更努力地分享高质内容给大家~~