【Leetcode】Sort List

Sort a linked list in O(n log n) time using constant space complexity.

Java:

Code Ganker：http://blog.csdn.net/linhuanmars/article/details/21133949

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
		return mergeSort(head);
    }
    
    
    public ListNode mergeSort(ListNode head) {
		if(head==null||head.next==null) return head;
		ListNode walker=head;
		ListNode runner=head;
		while(runner.next!=null && runner.next.next!=null)
		{
		    walker=walker.next;
		    runner=runner.next.next;
		    
		}
		ListNode head2=walker.next;
		walker.next=null;
		ListNode head1=head;
		head1=mergeSort(head1);
		head2=mergeSort(head2);
		return merge(head1,head2);
    }  
    public ListNode merge(ListNode head1, ListNode head2)
    {
        ListNode helper=new ListNode(0);
        helper.next = head1;  
        ListNode pre = helper;
        while(head1!=null&&head2!=null)
        {
            if(head1.val>head2.val)
            {
                ListNode next=head2.next;
                head2.next=pre.next;
                pre.next=head2;
                head2=next;
            }
            else{
                head1=head1.next;
            }
            pre=pre.next;
        }
        
        if(head2!=null)
        {
            pre.next=head2;
        }
        return helper.next;
 }
}

另一种解法：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
		if (head == null || head.next == null) {
			return head;
		}

		ListNode fast = head;
		ListNode slow = head;

		while (fast.next != null) {
			fast = fast.next.next;
			if (fast == null) {
				break;
			}

			slow = slow.next;
		}

		ListNode right = slow.next;
		slow.next = null;

		ListNode left = sortList(head);
		right = sortList(right);

		return mergeTwoLists(left, right);
    }
    
    
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
		if (l1 == null) {
			return l2;
		}
		if (l2 == null) {
			return l1;
		}

		ListNode node = null;
		ListNode head = null;

		while (l1 != null && l2 != null) {
			if (l1.val <= l2.val) {
				if (node == null) {
					node = l1;
					head = node;
				} else {
					node.next = l1;
					node = node.next;
				}

				l1 = l1.next;
			} else {
				if (node == null) {
					node = l2;
					head = node;
				} else {
					node.next = l2;
					node = node.next;
				}

				l2 = l2.next;
			}
		}

		if (l1 != null) {
			node.next = l1;
		} else if (l2 != null) {
			node.next = l2;
		}

		return head;
    }
}