【Java】 大話數據結構(17) 排序算法(4) （歸併排序）

　　本文根據《大話數據結構》一書，實現了Java版的歸併排序。

更多：數據結構與算法合集

基本概念

　　歸併排序：將n個記錄的序列看出n個有序的子序列，每一個子序列長度爲1，而後不斷兩兩排序歸併，直到獲得長度爲n的有序序列爲止。

　　歸併方法：每次在兩個子序列中找到較小的那一個賦值給合併序列（經過指針進行操做）。當一個子序列遍歷完成後，將另外一個序列中剩下數賦值給合併序列。（詳見代碼）

歸併排序示意圖

 

完整Java代碼

（含測試代碼）

public class MergeSort {
    public void mergeSort(int[] arr) {
        if(arr==null || arr.length<=0)
            return;
        mSort(arr,0,arr.length-1);
    }
 
    private  void mSort(int[] arr, int start, int end) {
        if(start==end)
            return;
        int mid=(start+end)/2;
        mSort(arr,start,mid);
        mSort(arr, mid+1, end);
        merge(arr,start,mid,end);
    }
 
    private void merge(int[] arr, int start, int mid, int end) {
        int[] temp=new int[end-start+1];    //存放排序號數據的臨時區域
        int k=0;        //臨時區域的指針
        int i=start;    //第一個有序區的指針
        int j=mid+1;    //第二個有序區的指針
         
        while(i<=mid && j<=end) {
            if(arr[i]<=arr[j])
                temp[k++]=arr[i++];
            else
                temp[k++]=arr[j++];
        }
        while(i<=mid)
            temp[k++]=arr[i++];
        while(j<=end)
            temp[k++]=arr[j++];
         
        for(k=0;k<=end-start;k++)
            arr[k+start]=temp[k];
    }
     
    //==========測試代碼=================
    public void test1() {
        int[] a = null;
        mergeSort(a);
        System.out.println(Arrays.toString(a));
    }
 
    public void test2() {
        int[] a = {};
        mergeSort(a);
        System.out.println(Arrays.toString(a));
    }
 
    public void test3() {
        int[] a = { 1 };
        mergeSort(a);
        System.out.println(Arrays.toString(a));
    }
 
    public void test4() {
        int[] a = { 3, 3, 3, 3, 3 };
        mergeSort(a);
        System.out.println(Arrays.toString(a));
    }
 
    public void test5() {
        int[] a = { -3, 6, 3, 1, 3, 7, 5, 6, 2 };
        mergeSort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void main(String[] args) {
        MergeSort demo =new MergeSort();
        demo.test1();
        demo.test2();
        demo.test3();
        demo.test4();
        demo.test5();
    }
}

　　

null
[]
[1]
[3, 3, 3, 3, 3]
[-3, 1, 2, 3, 3, 5, 6, 6, 7]

MergeSort

 

複雜度

 　　時間複雜度：O(nlogn)。假設序列有n個數，遍歷一次時間複雜度爲O(n)，遍歷次數爲二叉樹的深度log(2)n，因此時間複雜度爲O(nlogn)。

　　歸併排序是一種比較佔用內存，但效率高且穩定的算法。

 

更多：數據結構與算法合集