Leetcode - Sort List

My code:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null)
            return null;
        int count = 0;
        ListNode temp = head;
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        return sortList(head, count);
    }
    
    private ListNode sortList(ListNode head, int count) {
        if (count <= 1)
            return head;
        
        int left = 0;
        int right = 0;
        if (count % 2 == 0)
            left = count / 2;
        else
            left = count / 2 + 1;
        right = count - left;
        
        ListNode leftHead = head;
        ListNode rightHead = null;
        int countNode = 0;
        ListNode temp = head;
        while (temp != null) {
            countNode++;
            if (countNode == left) {
                rightHead = temp.next;
                temp.next = null;
                break;
            }
            else
                temp = temp.next;
        }
        
        ListNode subLeftHead = sortList(leftHead, left);
        ListNode subRightHead = sortList(rightHead, right);
        ListNode dummyNode = new ListNode(-1);
        ListNode tempDummy = dummyNode;
        int countLeft = 0;
        int countRight = 0;
        while (countLeft < left && countRight < right) {
            if (subLeftHead.val <= subRightHead.val) {
                tempDummy.next = subLeftHead;
                subLeftHead = subLeftHead.next;
                tempDummy = tempDummy.next;
                countLeft++;
            }
            else {
                tempDummy.next = subRightHead;
                subRightHead = subRightHead.next;
                tempDummy = tempDummy.next;
                countRight++;
            }
        }
        if (countLeft == left)
            tempDummy.next = subRightHead;
        else
            tempDummy.next = subLeftHead;
        
        return dummyNode.next;
    }
    
    public static void main(String[] args) {
        ListNode n1 = new ListNode(8);
        ListNode n2 = new ListNode(7);
        ListNode n3 = new ListNode(6);
        ListNode n4 = new ListNode(5);
        ListNode n5 = new ListNode(4);
        ListNode n6 = new ListNode(3);
        ListNode n7 = new ListNode(2);
        ListNode n8 = new ListNode(1);
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = n6;
        n6.next = n7;
        n7.next = n8;
        
        Solution test = new Solution();
        ListNode head = test.sortList(n1);
        while (head != null) {
            System.out.println(head.val);
            head = head.next;
        }
    }
}

My test result:

Paste_Image.png

這次作業(yè)說實話不難,但是要完全寫出來還是有點細節(jié)的。
首先,一開始我很難理解,鏈表麻痹怎么排序啊,還是歸并排序。
后來發(fā)現(xiàn)必須得統(tǒng)計結點個數(shù),接下來就好做點了。
用遞歸么,一層層遞歸下去,用普林斯頓算法課的說法叫做, bottom -up.
分成一塊一塊,然后再一塊塊拼裝起來。
思想還是歸并排序的思想,在這里我想說一個小技巧,那就是, dummy node.
真的很好用,尤其對于鏈表,很多復雜情況不需要在考慮了。
還有這里有個細節(jié),
因為我們要把一個鏈表切成兩段,然后分別遞歸,事實上這兩個子鏈表還是連接在一起的,所以我們需要人為得把他們切斷,
即 temp.next = null;
然后再遞歸。這是一個注意點。
同時,鏈表操作我還是有些地方?jīng)]注意到,像這道題目,通過dummy node來將兩個子鏈表合二為一,并且排序,沒有用到額外的空間,dummy node 就像是細線一樣,將這些結點重新串在了一塊兒。

**
總結: Merge Sort, LinkedList, Recursion
剛寫代碼,一個很久以前的朋友突然找我,上來第一句話就是,
以后去哪里發(fā)展?
很有社會上的口氣。我就和他聊了開來,一開始是有提防心的,比如他問我在不在家,之類的,我都回避,但聊著聊著就聊開了。某人估計又要罵我傻逼了吧。
他要結婚了,然后一直說我了不起,本科,研究生的大學都很強,學歷高。
說真的,我從來沒覺得我的學校很強,覺得可以拿這個去比,從來沒覺得。
但是,從他嘴中,我了解到了社會,尤其中國社會,原來這么看重學歷。甚至高中是哪里的都很看重。那我應該更加自信點了,雖然以前我一直覺得一個人該有相當?shù)谋臼略儆邢喈數(shù)淖孕牛F(xiàn)在看來,學歷也是那么重要,即使你什么都不會。
但是,我現(xiàn)在很努力,為什么?就像我之前努力出國,為什么,真的不是為了學歷。。當然學校是否有名也是有考慮的,但更多的,是想有一個好的環(huán)境讓我去學習技術。所以其實我的出發(fā)點還是比較純潔的,這也可能是我為什么能持續(xù)走下去的原因之一吧,因為我真的有這個需求,我很想學習這方面的知識。
女朋友的事,我這幾天是有點操之過急了,畢竟她才培訓一個禮拜啊,那么忙,身體也那么累,不像我回家還休息了一兩天,然后之后也是懶散的學習。我真的把她當成了機器,雖然我的本心是好的,但我就是把她當成了機器,按照我的設計而去學習。這是不對的。
但同樣,她也還是不夠拼命,也許還沒開始吧。希望下周可以真正開始了。
Because TOEFL is on the way.
**

Anyway, Good luck, Richardo!

My code:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null)
            return null;
        return sort(head);    
    }
    
    /** sort this list */
    private ListNode sort(ListNode head) {
        if (head == null || head.next == null)
            return head;
        ListNode slow = head;
        ListNode fast = head;
        /** find the middle node in the linkedlist using slow and fast pointers */
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next; // jump 1 node for slow pointer
            fast = fast.next; // jump 2 nodes for fast pointer
            fast = fast.next;
        }
        
        ListNode leftHead = head;
        ListNode rightHead = slow.next;
        slow.next = null; // cut the connection between left and right sub linked list
        /** sort these two sub linked lists separately */
        leftHead = sort(leftHead); // make sure this sub lis is sorted
        rightHead = sort(rightHead);
        /** merge them into one sorted linked list */
        return merge(leftHead, rightHead);
    }
    
    /** merge these two sub sorted lists */
    private ListNode merge(ListNode leftHead, ListNode rightHead) {
        if (leftHead == rightHead)
            return leftHead;
        ListNode leftScanner = leftHead;
        ListNode rightScanner = rightHead;
        ListNode head;
        /** ensure the head node */
        if (leftHead.val < rightHead.val) {
            head = leftHead;
            leftScanner = leftScanner.next;
        }
        else {
            head = rightHead;
            rightScanner = rightScanner.next;
        }
        ListNode scanner = head;
        /** merge two linked lists until one of them is finished */
        while (leftScanner != null && rightScanner != null) {
            if (leftScanner.val < rightScanner.val) {
                scanner.next = leftScanner;
                leftScanner = leftScanner.next;
            }
            else {
                scanner.next = rightScanner;
                rightScanner = rightScanner.next;
            }
            scanner = scanner.next;
        }
        /** connect the rest of the other list to this new sorted list */
        if (leftScanner == null)
            scanner.next = rightScanner;
        else
            scanner.next = leftScanner;
        return head;
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        ListNode a0 = new ListNode(3);
        ListNode a1 = new ListNode(2);
        ListNode a2 = new ListNode(4);
        a0.next = a1;
        a1.next = a2;
        ListNode head = test.sortList(a0);
        while (head != null) {
            System.out.println(head.val);
            head = head.next;
        }
    }
}

這道題目寫了一會兒。以前的寫法是不對的。因為我聲明了一個dummy node需要內(nèi)存,然后一層層下來就是, log(n) 的復雜度,就不再是常數(shù)級別了。
然后其他就差不多了,就是 merge sort the linked list

Anyway, Good luck, Richardo!

My code:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        return helper(head);
    }
    
    private ListNode helper(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode right = slow.next;
        ListNode left = head;
        slow.next = null;
        left = helper(left);
        right = helper(right);
        return merge(left, right);
    }
    
    private ListNode merge(ListNode leftHead, ListNode rightHead) {
        if (leftHead == null) {
            return rightHead;
        }
        else if (rightHead == null) {
            return leftHead;
        }
        
        ListNode left = leftHead;
        ListNode right = rightHead;
        ListNode dummy = new ListNode(-1);
        ListNode curr = dummy;
        
        while (left != null || right != null) {
            if (left == null) {
                curr.next = right;
                curr = curr.next;
                right = right.next;
            }
            else if (right == null) {
                curr.next = left;
                curr = curr.next;
                left = left.next;
            }
            else if (left.val < right.val) {
                curr.next = left;
                curr = curr.next;
                left = left.next;
            }
            else {
                curr.next = right;
                curr = curr.next;
                right = right.next;
            }
        }
        
        return dummy.next;
        
    }
}

這道題目本身沒有什么難度。空間復雜度是O(1),雖然用了dummy node,但是是在merge中使用的,使用完了后立刻釋放。

Anyway, Good luck, Richardo! -- 08/17/2016

最后編輯于
?著作權歸作者所有,轉載或內(nèi)容合作請聯(lián)系作者
平臺聲明:文章內(nèi)容(如有圖片或視頻亦包括在內(nèi))由作者上傳并發(fā)布,文章內(nèi)容僅代表作者本人觀點,簡書系信息發(fā)布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內(nèi)容