LeetCode系列148—排序链表

题意

148. 排序链表

题解

方法一：自顶向下归并排序

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* sortList(ListNode* head) {
    
    
        ListNode* pre = new ListNode();
        pre->next = head;
        ListNode* low = pre;
        ListNode* fast = pre;
        while (fast->next && fast->next->next) {
    
    
            low = low->next;
            fast = fast->next->next;
        }
        if (low == fast) return head;
        ListNode* tmp = low->next;
        low->next = nullptr;
        return mergeList(sortList(head), sortList(tmp));     
    }

    ListNode* mergeList(ListNode* list1, ListNode* list2) {
    
    
        if (list1 == nullptr) return list2;
        if (list2 == nullptr) return list1;
        if (list1->val <= list2->val) {
    
    
            list1->next = mergeList(list1->next, list2);
            return list1;
        } else {
    
    
            list2->next = mergeList(list1, list2->next);
            return list2;
        }
    }
};

时间复杂度：O(nlogn)
空间复杂度：O(nlogn)

方法二：自底向上归并排序

class Solution {
    
    
public:
    ListNode* sortList(ListNode* head) {
    
    
        if (head == nullptr) {
    
    
            return head;
        }
        int length = 0;
        ListNode* node = head;
        while (node != nullptr) {
    
    
            length++;
            node = node->next;
        }
        ListNode* dummyHead = new ListNode(0, head);
        for (int subLength = 1; subLength < length; subLength <<= 1) {
    
    
            ListNode* prev = dummyHead, *curr = dummyHead->next;
            while (curr != nullptr) {
    
    
                ListNode* head1 = curr;
                for (int i = 1; i < subLength && curr->next != nullptr; i++) {
    
    
                    curr = curr->next;
                }
                ListNode* head2 = curr->next;
                curr->next = nullptr;
                curr = head2;
                for (int i = 1; i < subLength && curr != nullptr && curr->next != nullptr; i++) {
    
    
                    curr = curr->next;
                }
                ListNode* next = nullptr;
                if (curr != nullptr) {
    
    
                    next = curr->next;
                    curr->next = nullptr;
                }
                ListNode* merged = merge(head1, head2);
                prev->next = merged;
                while (prev->next != nullptr) {
    
    
                    prev = prev->next;
                }
                curr = next;
            }
        }
        return dummyHead->next;
    }

    ListNode* merge(ListNode* head1, ListNode* head2) {
    
    
        ListNode* dummyHead = new ListNode(0);
        ListNode* temp = dummyHead, *temp1 = head1, *temp2 = head2;
        while (temp1 != nullptr && temp2 != nullptr) {
    
    
            if (temp1->val <= temp2->val) {
    
    
                temp->next = temp1;
                temp1 = temp1->next;
            } else {
    
    
                temp->next = temp2;
                temp2 = temp2->next;
            }
            temp = temp->next;
        }
        if (temp1 != nullptr) {
    
    
            temp->next = temp1;
        } else if (temp2 != nullptr) {
    
    
            temp->next = temp2;
        }
        return dummyHead->next;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/sort-list/solution/pai-xu-lian-biao-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

时间复杂度：O(nlogn)
空间复杂度：O(1)

参考

排序链表