[Leetcode148]排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

首先考虑用递归的方法：

python（递归）：

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

class Solution(object):
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head is None or head.next is None:
            return head
        mid = self.searchMid(head)
        l = head
        r = mid.next
        mid.next = None
        return self.merge(self.sortList(l),self.sortList(r))
    
    def merge(self,l,r):
        begin = ListNode(0)
        head = begin
        while l and r:
            if l.val >= r.val:
                head.next = r
                r = r.next
            else:
                head.next = l
                l = l.next
            head = head.next
        if l:
            head.next = l
        if r:
            head.next = r
        return begin.next
    
    def searchMid(self,node):
        if node is None:
            return node
        slow = node
        fast = node
        while(fast.next and fast.next.next):
            slow = slow.next
            fast = fast.next.next
        return slow

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 || !(head->next)) return head;
        ListNode* mid = searchMid(head);
        ListNode* l = head;
        ListNode* r = mid->next;
        mid->next = NULL;
        return merge(sortList(l),sortList(r));
        
    }
    ListNode* merge(ListNode* l,ListNode* r){
        ListNode* begin = new ListNode(0);
        ListNode* head = begin;
        while(l && r){
            if(l->val < r->val){
                head->next = l;
                l = l->next;
            }
            else{
                head->next = r;
                r = r->next;
            }
            head = head->next;
        }
        if(l) head->next = l;
        if(r) head->next = r;
        return begin->next;
    }
    ListNode* searchMid(ListNode* node){
        if(!node) return node;
        ListNode* slow = node;
        ListNode* fast = node;
        while(fast->next && fast->next->next){
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

然后考虑将链表的值保存在列表或者容器里然后用内置函数进行排序。

python：

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

class Solution(object):
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        a = []
        while head:
            a.append(head.val)
            head = head.next
        a.sort()
        begin = ListNode(0)
        begin.next = None
        head = begin
        for i in range(len(a)):
            tmp = ListNode(a[i])
            tmp.next = None
            begin.next = tmp
            begin = tmp
        return head.next

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) {
        vector<int> res;
        while(head){
            res.push_back(head->val);
            head = head->next;
        }
        sort(res.begin(),res.end());
        ListNode* h = new ListNode(0);
        ListNode* begin = h;
        for(int i = 0;i < res.size();i++){
            ListNode* tmp = new ListNode(res[i]);
            h->next = tmp;
            h = tmp;
        }
        return begin->next;
    }
};