歸併排序和快速排序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)。但它是不穩定排序。包含重複元素時，用三路切分來優化複雜度

如果對你有幫助的話來個讚唄，如果有什麼問題歡迎交流，我會更努力地分享高質內容給大家~~