常見的鏈表排序（Java版）

       上篇博客中講解了九大內部排序算法，部分算法還提供了代碼實現，但是那些代碼實現都是基於數組進行排序的，本篇博客就以鏈表排序實現幾種常見的排序算法，以饗讀者。

 

快速排序的鏈表實現

算法思想：對於一個鏈表，以head節點的值作為key，然后遍歷之后的節點，可以得到一個小於key的鏈表和大於等於key的鏈表；由此遞歸可以對兩個鏈表分別進行快速。這里用到了快速排序的思想即經過一趟排序能夠將小於key的元素放在一邊，將大於等於key的元素放在另一邊。

代碼實現：

    //快速排序
    public static void quickSort(ListNode begin, ListNode end){
        if(begin == null || begin == end)
            return;
        
        ListNode index = paration(begin, end);
        quickSort(begin, index);
        quickSort(index.next, end);
    }
    
    /**
     * 划分函數，以頭結點值為基准元素進行划分
     * @param begin
     * @param end
     * @return
     */
    public static ListNode paration(ListNode begin, ListNode end){
        if(begin == null || begin == end)
            return begin;
        
        int val = begin.val;  //基准元素
        ListNode index = begin, cur = begin.next;
        
        while(cur != end){
            if(cur.val < val){  //交換
                index = index.next;
                int tmp = cur.val;
                cur.val = index.val;
                index.val = tmp;
            }
            cur = cur.next;
        }
        
        
        begin.val = index.val;
        index.val = val;
        
        return index;
    }

歸並排序的鏈表實現

算法思想：單鏈表與數組相比只能順序訪問每個元素，因此在使用二路歸並排序時關鍵在於找到鏈表的中間結點將鏈表一分為二：可以利用快慢指針同時遍歷單鏈表，當步長為2的指針指向鏈表最后一個結點或者最后一個結點的下一個結點時，步長為1的指針即指向鏈表的中間結點。然后是兩個有序單鏈表的合並問題。時間復雜度為O(N*logN)，空間復雜度為O(1)。

代碼實現：

    //歸並排序
    public static ListNode mergeSort(ListNode head){
        if(head == null || head.next == null)  //空鏈表或者只有單個結點
            return head;
        ListNode slow = head, fast = head.next;
        
        while(fast != null && fast.next != null){  //使用快慢指針尋找中間 結點
            slow = slow.next;
            
            fast = fast.next;
            if(fast.next != null)
                fast = fast.next;        
        }
        
        ListNode ptr1 = slow.next;
        slow.next = null;
        
        ListNode tmp1 = mergeSort(head);
        ListNode tmp2 = mergeSort(ptr1);
        return merge(tmp1, tmp2);
    }
    
    
    public static ListNode merge(ListNode start1,  ListNode start2){
        ListNode header = new ListNode(-1);
        ListNode pre = header;
        
        ListNode ptr1 = start1, ptr2 = start2;
        while(ptr1 != null && ptr2 != null){
            if(ptr1.val <= ptr2.val){
                pre.next = ptr1;
                pre = ptr1;
                ptr1 = ptr1.next;
            }else{
                pre.next = ptr2;
                pre = ptr2;
                ptr2 = ptr2.next;
            }
        }
        while(ptr1 != null){
            pre.next = ptr1;
            pre = ptr1;
            ptr1 = ptr1.next;
        }
        
        while(ptr2 != null){
            pre.next = ptr2;
            pre = ptr2;
            ptr2 = ptr2.next;
        }
        
        
        return header.next;
        
    }

冒泡排序的鏈表實現

算法思想：依次比較相鄰的結點，如果是逆序的就交換兩個結點

代碼實現：

    //冒泡排序
    public static ListNode bubbleSort(ListNode head){
        if(head == null || head.next == null)  //鏈表為空或者僅有單個結點
            return head;
        
        ListNode cur = null, tail = null;
        
        cur = head;
        
        while(cur.next != tail){
            while(cur.next != tail){
                if(cur.val > cur.next.val){
                    int tmp = cur.val;
                    cur.val = cur.next.val;
                    cur.next.val = tmp;
                }
                cur = cur.next;
            }
            
            tail = cur;  //下一次遍歷的尾結點是當前結點(仔細琢磨一下里面的道道)
            cur = head;     //遍歷起始結點重置為頭結點    
        }
        
        return head;
        
        
    }

先寫這幾種吧，想起來再更。。。