[leetcode]Sort List @ Python

原題地址：http://oj.leetcode.com/problems/sort-list/

題意：鏈表的排序。要求：時間復雜度O(nlogn)，空間復雜度O(1)。

解題思路：由於題目對時間復雜度和空間復雜度要求比較高，所以查看了各種解法，最好的解法就是歸並排序，由於鏈表在歸並操作時並不需要像數組的歸並操作那樣分配一個臨時數組空間，所以這樣就是常數空間復雜度了，當然這里不考慮遞歸所產生的系統調用的棧。

　　　　   這里涉及到一個鏈表常用的操作，即快慢指針的技巧。設置slow和fast指針，開始它們都指向表頭，fast每次走兩步，slow每次走一步，fast到鏈表尾部時，slow正好到中間，這樣就將鏈表截為兩段。

　　　　   運行時需要將中文注釋刪掉，leetcode oj平台里面不支持中文字符。

代碼：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # @param head, a ListNode
    # @return a ListNode
    def merge(self, head1, head2):
        if head1 == None: return head2
        if head2 == None: return head1
        dummy = ListNode(0)                             #歸並時，新建一個鏈表頭結點
        p = dummy
        while head1 and head2:
            if head1.val <= head2.val:
                p.next = head1
                head1 = head1.next
                p = p.next
            else:
                p.next = head2
                head2 = head2.next
                p = p.next
        if head1 == None:
            p.next = head2
        if head2 == None:
            p.next = head1
        return dummy.next
        
    def sortList(self, head):
        if head == None or head.next == None:
            return head
        slow = head; fast = head                        #快慢指針技巧的運用，用來截斷鏈表。
        while fast.next and fast.next.next:
            slow = slow.next
            fast = fast.next.next
        head1 = head
        head2 = slow.next
        slow.next = None                                #head1和head2為截為兩條鏈表的表頭
        head1 = self.sortList(head1)
        head2 = self.sortList(head2)
        head = self.merge(head1, head2)
        return head