[leetcode]Sort List

链表用归并排序，之前也做过，用递归写很简单，代码不长也很好理解。地址

但是今天无聊想用非递归写下。

基本思想就是每次就是1,2,4,8,16这样分块。。然后比较，合并。

想法很简单，结果代码写出来也debug了一小会儿。

主要遇到的问题就是，在merge两个list的时候(其实就是一个的两部分)，怎么处理末尾和开始。

没处理好，可能就是个环。

还是在代码里面注视说好点。

class Solution {
public:
    ListNode *get_next(ListNode* head, int n) {
        while(n-->0 && head) {
            head = head->next;
        }
        return head;
    }
    
    ListNode* merge2(ListNode* l1, ListNode* l2, int n, int pos, int len) {
        ListNode* dummy = new ListNode(-1);
        ListNode* curr = dummy;
        ListNode* le = l2;
        int n1 = min(n, len - pos); // 计算l1有多少个节点
        int n2 = min(n, len - (pos+n)); // 计算l2有多少个节点
        while(n1 > 0 && n2 > 0) { //开始是用l1,l2这样表示的，明显的问题，只是其中一段，next肯定不是nullptr
            if (l1->val < l2->val) {
                curr->next = l1;
                l1 = l1->next;
                n1--;
            } else {
                curr->next = l2;
                n2--;
                l2 = l2->next;
            }
            curr = curr->next;
        }
        if (n1 > 0&& l1) curr->next = l1;
        if (n2 > 0&& l2) curr->next = l2;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
    
    ListNode *sortList(ListNode *head) {
        if (head == nullptr || head->next == nullptr) return head;
        int len = 0;
        for (ListNode* tmp = head; tmp; tmp = tmp->next) {
            len++;
        }
        int step = 1; // step = 1,2,4,6,8

        while (step < len ) {
            ListNode* curr = head;
            ListNode* prev = nullptr;
            for (int i = 0; i < len; i += step*2) { //i其实就是curr在list里面的位置
                ListNode* next = get_next(curr, step*2); //记录next...不然前面重排之后不好找
                ListNode* tmp = merge2(curr, get_next(curr, step), step, i, len); // l1 是当前节点的step个，l2是step+1到step*2个
                if (i == 0) head = tmp; //每次迭代head可能都会变
                curr = tmp;
                if (prev) prev->next = curr; //把前面的指向现在的head
                prev = get_next(curr, step * 2 - 1);  //这个是现在l1,l2合并后的最后一个节点，就是后面的prev
                curr = next; //curr指向下一个
            }
            step *= 2;
        }
        ListNode* curr = get_next(head, len - 1);//最后的节点的next其实可能还指向了某些地方的 2->1这种，我们排序之后是1->2但是2还是指向1的，就有环
        curr->next = nullptr;
        return head;
    }
    
};