歸併排序：陣列和連結串列的多種實現

思想

將陣列進行分割，形成多個組合並繼續分割，一直到每一組只有一個元素時，此時可以看作每一組都是有序的

然後逐漸合併相鄰的有序組合（合併之後也是有序的），分組個數呈倍數減少，每一組的元素個數呈倍數增長

一直到只剩下一個組合包含所有元素，將代表著陣列排序完畢

歸併排序是一種類似二叉樹遍歷的實現，所以時間複雜度與二叉樹遍歷一樣：o(n*log2n)

本來畫了個圖，但是因為太醜了，所以放在最下面

陣列的歸併排序實現

自頂向下

使用遞迴不斷往下遍歷，一直到當前組合只有一個元素，開始回溯，將相鄰的組合進行合併，直到最後只剩下一個組合，陣列即有序。

比如

44,8,33,5,1,9,2這組數字使用歸併排序的流程通過執行結果可以看到
首先遞迴到只有44一個元素的組合，然後回溯，等待相鄰組合變成有序之後，與相鄰組合8進行合併
44 ， 8 這個組合 又等待相鄰組合 33 ， 5 變成有序之後，進行合併，一直到合併完畢
每次合併的相鄰組合擁有的元素個數，必須與當前組合相等或者不足

 

 實現程式碼

import java.util.Arrays;

public class MergeSortDemo {

    public static void main(String[] args) {

        int[] arr = new int[]{44,8,33,5,1,9,2};

        System.out.println(Arrays.toString(arr));

        mergeSort(arr,0,arr.length-1);

        System.out.println(Arrays.toString(arr));

    }


    public static void mergeSort(int[] arr,int left,int right){

        if(left >= right){
            return;
        }
        int mid = (right - left)/2 + left;

        mergeSort(arr,left,mid);

        mergeSort(arr,mid+1,right);

        merge(arr,left,mid,right);
    }
    public static void merge(int[] arr,int left,int mid,int right){

        int len = right - left + 1;


        //分別記錄兩組元素的起始位置和結束位置
        int s1 = left, e1 = mid,s2 = mid+1 , e2 = right;

        int[] newArr = new int[len];
        int index = 0;

        //將兩組元素進行合併
        while (s1 <= e1 && s2 <= e2){

            if(arr[s1] > arr[s2]){
                newArr[index++] = arr[s2++];
            }else {
                newArr[index++] = arr[s1++];
            }
        }

        while (s1 <= e1){
            newArr[index++] = arr[s1++];
        }

        while (s2 <= e2){
            newArr[index++] = arr[s2++];
        }
        //將排序好的結果複製回原陣列
        //新陣列的下標[0...index] 對應 原陣列[left...right]
        for (int i = left; i <= right; i++) {
            arr[i] = newArr[i - left];
        }
    }
}

 

 

 自底向上

自底向上沒有使用遞迴的方式，而是使用迴圈修改陣列

首先設定一個分割值gap進行分組，每個組合的元素數量為gap，從1開始，呈倍數增長，一直到等於陣列長度n

在gap每次增長之前，都將相鄰的組合進行合併，由n個組合併為1個組

通過執行結果可以看出，執行中有兩層迴圈

第一層迴圈不斷增長gap的值

第二層迴圈，根據gap的值，沿著陣列每次找出兩個組合，進行合併，一直到找不到為止

合併過程與上面的做法類似

 

 實現程式碼

public class MergeSortDemo {

    public static void main(String[] args) {

        int[] arr = new int[]{44,8,33,5,1,9,2};

        System.out.println(Arrays.toString(arr));

        merge1(arr);

        System.out.println(Arrays.toString(arr));

    }

    public static void merge1(int[] arr){


        int gap = 1 , len = arr.length;

        while (gap < len){

            int start = 0;

            while (start < len){
                //兩個組合的起點
                int s1 = start , s2 = start + gap ;
                //終點
                int e1 = s2 -1,e2 = s2 + gap - 1;

                //陣列長度不足，沒有第二個組合了
                if(s2 >= len){
                    break;
                }

                //第二個組合長度小於第一個組合
                if(e2 >= len){
                    e2 = len - 1;
                }
                
                int left = start,right = e2;

                int index = 0;
                
                int size = right - left + 1;
                int[] tmpArr = new int[size];

                while (s1 <= e1 && s2 <= e2){
                    if(arr[s1] < arr[s2]){
                        tmpArr[index] = arr[s1++];
                    }else {
                        tmpArr[index] = arr[s2++];
                    }

                    index++;
                }

                while (s1 <= e1){
                    tmpArr[index++] = arr[s1++];
                }

                while (s2 <= e2){
                    tmpArr[index++] = arr[s2++];
                }

                for (int i = left; i <= right ; i++) {
                    arr[i] = tmpArr[i - left];
                }

                start = e2 + 1;
            }

            gap *= 2;
        }
    }
}        

 

連結串列的歸併排序實現

連結串列的資料結構

public class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }

}

連結串列跟陣列相比，不能用下標訪問，不知道長度，不能立即分割。

連結串列的賦值使用一個不儲存資料的頭節點，將資料往後插入。

跟陣列不一樣的是，連結串列需要真正的把節點一個個分割，在合併時再將節點連線起來。

 

自頂向下

不斷使用快慢指標得出連結串列中間節點，將整個連結串列進行分割，一直分割到每個連結串列都只有一個節點時再合併

 程式碼實現

public class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }


    public static void main(String[] args) {
        //頭節點不儲存資料
        ListNode tou = new ListNode();
        ListNode tmp = tou;
        int[] arr = new int[]{44,8,33,5,1,9,2};

        //藉助臨時節點擴充連結串列
        for (int i = 0; i < 7; i++) {
            tmp.next = new ListNode();
            tmp = tmp.next;
            tmp.val = arr[i];
        }

        ListNode sortedHead = sortList(tou.next);

        while (sortedHead != null){
            System.out.print(sortedHead.val + ",");
            sortedHead = sortedHead.next;
        }
    }

    public static ListNode sortList(ListNode head) {

        if(head == null || head.next == null){
            return head;
        }

        ListNode fast = head,slow = head;

        //快指標走的步數 = 慢指標 * 2
        /*
        連結串列長度為偶數時，快指標到倒數第二個節點，慢指標到中間兩個節點中的前一個
        奇數時，快指標到最後一個節點，慢指標到中間節點
         */
        //當快指標沒法走下去時，說明慢指標已經到達了連結串列的中間節點
        while (fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //第二部分的開始節點
        ListNode mid = slow.next;
        //分割出第一部分
        slow.next = null;

        //當連結串列的節點數量超過一個時，繼續分割
        if(head.next != null){
            head =  sortList(head);
        }

        if(mid.next != null){
            mid = sortList(mid);
        }

        return merge(head,mid);
    }

    public static ListNode merge(ListNode l1,ListNode l2){

        ListNode pre = new ListNode();
        ListNode tou = pre;
        while (l1 != null && l2 != null){
            pre.next = new ListNode();
            pre = pre.next;

            if(l1.val > l2.val){
                pre.val = l2.val;
                l2 = l2.next;

            }else {
                pre.val = l1.val;
                l1 = l1.next;
            }
        }
        //將剩餘的節點在後面插入
        pre.next = l1 == null ? l2 : l1;

        return tou.next;
    }
}

 

自底向上

要使用gap對連結串列分組，需要先計算連結串列的長度

與陣列一樣是兩層迴圈，第一層gap不斷倍增

第二層迴圈使用h作為不斷遍歷原連結串列的輔助節點，h1,h2確定兩個要合併的連結串列，i1,i2確定連結串列的長度，然後合併

程式碼實現

package node;

public class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }


    public static void main(String[] args) {
        //頭節點不儲存資料
        ListNode tou = new ListNode();
        ListNode tmp = tou;
        int[] arr = new int[]{44,8,33,5,1,9,2};

        //藉助臨時節點擴充連結串列
        for (int i = 0; i < 7; i++) {
            tmp.next = new ListNode();
            tmp = tmp.next;
            tmp.val = arr[i];
        }


       ListNode sortedHead = merge1(tou.next);

        while (sortedHead != null){
            System.out.print(sortedHead.val + ",");
            sortedHead = sortedHead.next;
        }
    }

    //自底向上的歸併排序
    public static ListNode merge1(ListNode head){

        int len = 0 , gap = 1;
        ListNode tmp = head;
        while (tmp != null){
            tmp = tmp.next;
            len++;
        }

        ListNode pre,h,h1,h2 ;
        ListNode tou = new ListNode();
        tou.next = head;
        
        /*
        每次迴圈指定一個頭節點，從該節點開始根據gap去獲取要比較的兩部分的頭節點
        將兩個部分的節點按順序加入該節點
        該節點指向還沒排序的後續節點
         */
        while (gap < len){
            pre = tou;

            h = pre.next;
            while (h != null){
                int i1 = gap;
                h1 = h;
                while (i1 > 0 && h != null){
                    i1--;
                    h = h.next;
                }
                //第一部分已經到連結串列的終點
                if(i1 > 0){
                    break;
                }
                h2 = h;
                int i2 = gap;
                while (i2 > 0 && h != null){
                    i2--;
                    h = h.next;
                }

                int l1 = gap;
                //第二部分的長度
                int l2 = gap - i2;

                /*
                不用新建立節點的方式
                而是將現有節點插入到頭節點後面
                 */
                while (l1 > 0 && l2 > 0){
                    if(h1.val > h2.val){
                        pre.next = h2;
                        h2 = h2.next;
                        l2--;
                    }else {
                        pre.next = h1;
                        h1 = h1.next;
                        l1--;
                    }
                    pre = pre.next;
                }

                pre.next = l1 == 0 ? h2 : h1;
                //需要遍歷完已經合併的兩個連結串列，才能合併的後續連結串列
                while (l1 > 0 || l2 > 0){
                    pre = pre.next;
                    l1--;
                    l2--;
                }
                //將未排序的連結串列接在後面
                pre.next = h;
            }

            gap *= 2;
        }
        return tou.next;
    }
}

 

圖