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:
這次作業(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