【LeetCode】单链表排序：Insertion Sort List 和 Sort List

1. Insertion Sort List

Sort a linked list using insertion sort.

A graphical example of insertion sort. The partial sorted list (black) initially contains only the first element in the list.
With each iteration one element (red) is removed from the input data and inserted in-place into the sorted list
 

Algorithm of Insertion Sort:

1. Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list.
2. At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there.
3. It repeats until no input elements remain.

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4

Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5

解题思路：

• 遍历单链表，找到前半段已经排好序的链表中比当前结点大的元素的前驱结点，如果不存在，返回的是前半段链表中的尾结点；

class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        if(!head || !head->next) return head;
        
        ListNode *dummy = new ListNode(INT_MIN);
        //dummy->next = head; // 该行必须要注释掉，否则可能形成单链表环
        ListNode *cur = head;
        
        while(cur) {
            ListNode *pre = findInsertLocation(dummy, cur->val);
            ListNode *temp = cur->next;
            cur->next = pre->next;
            pre->next = cur;
            cur = temp;
        }
        
        return dummy->next;
    }
    
    ListNode* findInsertLocation(ListNode* dummy, int val) {
        ListNode *pre = nullptr, *p = dummy;
        while(p != nullptr) {
            if(p->val <= val) {
                pre = p;
                p = p->next;
            } else {
                break;
            }
        }
        return pre;
    }
};

2. Sort List

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

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4

Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5

解题分析：

• 该题和上题不一样，要求时间复杂度为nlogn，单链表适合用归并排序，双向链表适合用快速排序；

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head || !head->next) return head;
        
        ListNode *fast = head, *slow = head;
        while(fast->next != nullptr && fast->next->next != nullptr) {
            slow = slow->next;
            fast = fast->next->next;
        }
        
        fast = slow->next;
        slow->next = nullptr;
        ListNode *left = sortList(head);
        ListNode *right = sortList(fast);;
        
        return mergeTwoList(left, right);
    }
    
    ListNode* mergeTwoList(ListNode* left, ListNode* right) {
        ListNode *dummy = new ListNode(-1);
        ListNode *cur = dummy;
        
        while(left && right) {
            if(left->val < right->val) {
                cur->next = left;
                left = left->next;
            } else {
                cur->next = right;
                right = right->next;
            }
            cur = cur->next;
        }
        
        if(left) cur->next = left;
        if(right) cur->next = right;
        
        return dummy->next;
    }
};