歸並排序：數組和鏈表的多種實現

本文主要是數組和鏈表兩種結構，關於歸並排序算法的遞歸實現和非遞歸實現

思想

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

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

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

歸並排序是一種類似二叉樹遍歷的實現，所以時間復雜度與二叉樹遍歷一樣：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;
    }
}

 

圖