力扣 148. 排序链表 自下而上解法

题目来源：https://leetcode.cn/problems/sort-list/

大致题意：
给一个链表，将其升序排序后返回

思路

在上一个博客中，介绍了链表排序的自上而下的解法，通过分治法思想的分析，利用了归并排序的解法，实现了链表排序。

但是上述方法使用递归来解题，虽然每次方法中没使用额外的辅助空间，但是算法整体上递归栈的深度为 O(log n)，即空间复杂度仍为 O(log n)。

这里给出自下而上的解法，实现 O(1) 的空间复杂度

解题步骤可以概括为：

1. 获取链表的长度
2. 从长度为 1 开始，进行链表的两两合并，长度在每次排序后翻倍，直至长度大于等于链表长度
3. 每次对于当前排序长度 i，通过遍历获得两个长度为 i 的升序子链表（这里仍然是归并排序的思想，从长度为 1 的子链表开始合并，保证每次取出的子链表都是升序的），将两个子链表进行升序合并。重复本步操 作，指针无法获得两个子链表。注意，最后一次合并时，后一个子链表的长度可以小于 i

注意，在每轮排序时，需要分割子链表，并且要考虑到最后一个子链表长度小于当前排序的子链表长度的情况。

具体看代码：

public ListNode sortList(ListNode head) {
        int len = 0;
        ListNode node = head;
        // 获取链表长度
        while (node != null) {
            len++;
            node = node.next;
        }
        // 哨兵节点，将该节点的next指向链表头结点
        ListNode sentinel = new ListNode(-100001);
        sentinel.next = head;
        // 存上次排序后的尾结点
        ListNode pre;
        // 存当前遍历位置
        ListNode cur;
        // 从长度为 1 的子链表开始进行两两合并，直至子链表长度大于等于原链表
        for (int i = 1; i < len; i *= 2) {
            // 每次排序开始前，上一个排序后的尾结点置为哨兵节点
            pre = sentinel;
            // 当前遍历位置为头结点
            cur = sentinel.next;
            while (cur != null) {
                // 获取前一个子链表的头结点
                ListNode head1 = cur;
                // 遍历 i - 1 个位置
                for (int j = 1; j < i && cur.next != null; j++) {
                    cur = cur.next;
                }
                // 获取后一个链表的头结点
                ListNode head2 = cur.next;
                // 将前一个链表尾结点的 next 指针置为 null，分割两个子链表
                cur.next = null;
                // 当前遍历位置更新为后一个链表头结点
                cur = head2;
                // 如果后一个链表头节点为空
                if (cur == null) {
                    // 免去合并步骤，直接将前一个子链表接到当前已合并链表尾部
                    pre.next = head1;
                    // 跳出循环
                    break;
                }
                // 遍历 i - 1 个位置
                for (int j = 1; j < i && cur.next != null; j++) {
                    cur = cur.next;
                }
                // 获取下一轮合并的子链表头结点
                ListNode next = cur.next;
                // 将链表尾结点的 next 指针置为 null，分割子链表
                cur.next = null;
                // 更新当前遍历位置
                cur = next;
                // 合并两个子链表
                ListNode newHead = merge(head1, head2);
                // 将合并后的子链表加到之前合并链表的尾部
                pre.next = newHead;
                // 更新合并链表的尾指针
                while (pre.next != null) {
                    pre = pre.next;
                }
            }
        }
        return sentinel.next;
    }
    // 合并两个升序链表
    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode res = new ListNode(-100001);
        ListNode node = res;
        while (head1 != null || head2 != null) {
            if (head1 == null) {
                node.next = head2;
                head2 = head2.next;
            } else if (head2 == null) {
                node.next = head1;
                head1 = head1.next;
            } else if (head1.val > head2.val) {
                node.next = head2;
                head2 = head2.next;
            } else {
                node.next = head1;
                head1 = head1.next;
            }
            node = node.next;
        }
        return res.next;
    }