leetCode 147. 对链表进行插入排序

这道题有点搞，把它大事化小，分成了4步，每一步可以单独看是否正确。

Step0：链表节点结构体的定义，后面就不重复了。

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

Step1：反转链表。（实现节点的搬运）

class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode* dummy = new ListNode(0, head);
        ListNode
            *prev = dummy,
            *lastSorted = head, 
            *curr = head->next;
            // 最终的顺序是 lastSorted -> curr，接下来每次插入开始/结束时，都要维持这个顺序
        while(curr){
            lastSorted->next = curr->next; // 1 从链表中删除curr指向的node
            curr->next = prev->next; // 2
            prev->next = curr; // 3 上面两行，把 curr指向的node 插到prev指向的 node后面。在Step1，prev始终指向Dummy节点，所以每次的curr都插到Dummy后面，也就是第一个。整个循环也就成了反转链表。
            curr = lastSorted->next; // 4 调整curr指针，再次指向lastSorted->next，也就是本次循环开始前，自己的->next。
            // 1,4是删除curr, 2,3是插入curr. 在插之前先留住curr->next，因为插本身会更新curr->next
        } 
        return dummy->next;
    }
};

输入：[3,4,1,2]
输出：[2,1,4,3]

Step2 加个比大小的判断，如果被搬运的节点比它前一个小才搬。（实现是否搬运节点的判断）

class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode* dummy = new ListNode(0, head);
        ListNode
            *prev = dummy,
            *lastSorted = head, 
            *curr = head->next;
        while(curr){
            if(lastSorted->val > curr->val){ // 被搬的节点只比前一个节点小才被搬运
                lastSorted->next = curr->next;
                curr->next = prev->next;
                prev->next = curr;
            }
            else{
                lastSorted = lastSorted->next;
            }
            curr = lastSorted->next;
        }
        return dummy->next;
    }
};

输入： [3,4,1,2]
输出： [2,1,3,4]

Step3：加两行代码，每次搬运（如果需要），都只和前一个交换。（实现插入位置的移动）

实践发现这一步可以省略

class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode* dummy = new ListNode(0, head);
        ListNode
            *prev = dummy,
            *lastSorted = head, 
            *curr = head->next;
        while(curr){
            if(lastSorted->val > curr->val){
                while(prev->next != lastSorted) // 每次插入的位置（如果需要），往后遍历到当前节点的前一个节点的前一个节点，那么插入的位置就是当前节点的前一个节点前
                    prev = prev->next;
                lastSorted->next = curr->next;
                curr->next = prev->next;
                prev->next = curr;
                prev = dummy; // 插入后，恢复默认插入位置到链表头的后面
            }
            else{
                lastSorted = lastSorted->next;
            }
            curr = lastSorted->next;
        }
        return dummy->next;
    }
};

输入： [3,4,1,2]
输出： [3,1,2,4]

Step4：修改在Step3添加的while比大小条件，更新为找到比待搬运节点大第一个节点，在它之前插入。对每个节点进行搬运，也就成了插入排序。（实现插入位置的搜索）

class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode* dummy = new ListNode(0, head);
        ListNode
            *prev = dummy;
            *lastSorted = head, 
            *curr = head->next,
        while(curr){
            if(lastSorted->val > curr -> val){
                while(prev->next->val <= curr->val) // 遍历使插入位置为第一个 大于curr->val的节点前。
                    prev = prev->next;
                lastSorted->next = curr->next;
                curr->next = prev->next;
                prev->next = curr;
                prev = dummy;
            }
            else{
                lastSorted = lastSorted->next;
            }
            curr = lastSorted->next;
        } 
        return dummy->next;
    }
};

输入：[3,4,1,2]
输出：[1,2,3,4]