LeetCode 148 — Sort List（C++ Java Python）

题目：http://oj.leetcode.com/problems/sort-list/

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

题目翻译：

在O(nlogn)时间内，使用常数空间对链表进行排序。
分析：

        使用归并排序，复用Merge Two Sorted Lists代码。（http://blog.csdn.net/lilong_dream/article/details/20075857）

C++实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
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);
	}


	ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
		if(l1 == NULL)
		{
			return l2;
		}
		if(l2 == NULL)
		{
			return l1;
		}

		ListNode *node = NULL;

		if(l1->val <= l2->val)
		{
			node = l1;
			l1 = l1->next;
		}
		else
		{
			node = l2;
			l2 = l2->next;
		}

		ListNode *head = node;

		while(l1 != NULL && l2 != NULL)
		{
			if(l1->val <= l2->val)
			{
				node->next = l1;
				node = node->next;

				l1 = l1->next;
			}
			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;
	}
};

Java实现：

/**
 * 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;
    }
}

Python实现：（会超时）

# 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 sortList(self, head):
        if head == None or head.next == None:
            return head
        
        fast = head
        slow = head
        
        while fast.next != None:
            fast = fast.next.next
            if fast == None:
                break;
            
            slow = slow.next
        
        right = slow.next
        slow.next = None
        
        left = self.sortList(head)
        right = self.sortList(right)
        
        return self.mergeTwoLists(left, right)
        
        
    def mergeTwoLists(self, l1, l2):
        if l1 == None:
            return l2
        if l2 == None:
            return l1
        
        node = None
        
        while l1 != None and l2 != None:
            if l1.val <= l2.val:
                if node == None:
                    node = l1
                    head = node
                else:
                    node.next = l1
                    node = node.next
                    
                l1 = l1.next
            else:
                if node == None:
                    node = l2
                    head = l2
                else:
                    node.next = l2
                    node = node.next
                    
                l2 = l2.next
                    
        if l1 != None:
            node.next = l1
        elif l2 != None:
            node.next = l2
                    
        return head

        感谢阅读，欢迎评论！