leetcode每日一道（4）：在O(n log n)的时间内使用常数级空间复杂度对链表进行排序

题目描述

在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。
Sort a linked list in O(n log n) time using constant space complexity.

思路

既然是在常数的空间复杂度,即o(1)的空间复杂度内，那么递归是不能考虑了，这种情况下，只能考虑自底向上的循环方案。
代码就在下面，要注意的几点问题是：

• 虚拟头结点的使用，是一个非常重要的技巧。
• 断链的操作
• 合并的操作

代码

/**
 * 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) {
        ListNode DummyHead(0);
        DummyHead.next = head;
        auto p = head;
        // 计算链表长度
        int length = 0;
        while(p){
            length += 1;
            p = p->next;
        }
        for (int i=1; i<length; i<<=1){
            auto cur = DummyHead.next;
            auto tail = &DummyHead;//初始化tail存着虚节点的地址，以保证虚节点每次都能在更新后的链表的表头位置。
            //left = cut(q,i);
            while(cur){
                auto left = cur;// cut函数给定表头和长度，返回后段的表头。
                auto right = cut(cur,i);
                cur = cut(right,i);//防止找不到后面的表头，这里记录下来。
                tail->next = merge(left, right);//tail一直记录已经merge好的链尾。起到了连接的作用。
                while(tail->next){
                    tail = tail->next;
                }
                
            }
            
        }
        return DummyHead.next;
        }
        ListNode* cut(ListNode *head, int i){
            auto cur = head;
            while(--i && cur){
                cur = cur->next;
            }
            if(!cur) return nullptr;
            
            auto rightHead = cur->next;
            cur->next= nullptr;
            return rightHead;
        }
        ListNode* merge(ListNode *left, ListNode *right){
            ListNode DummyHead(0);
            auto p = &DummyHead;
            
            while(left && right){
                if (left->val < right->val) {
                    p->next = left;
                    p = left;
                    left = left->next;
                }
                else {
                    p->next = right;
                    p = right;
                    right = right->next;
                }
            }
            p->next = left?left:right;
            return DummyHead.next;
        }
    
};