瑞文考研算法每日一题—2023.05.26 重排链表

Problem: 143. 重排链表
此题为408统考2019真题原题，读者阅读后可以去尝试完成。

思路

  假设链表是$L1\to L2\to L3\to L4\to L5\to L6$，新的链表为$L1\to L6\to L2\to L5\to L3\to L4$。

  通过观察我们发现新的链表是将原链表拆分成了两个部分再进行合并，第一部分是$L1\to L2\to L3$，第二部分是$L6\to L5\to L4$，再将这两个链表依次合并则组成了新的所求链表。

  我们将这个问题拆分了成三个独立的问题，建议读者先完成这部分练习：

• 瑞文考研算法每日一题—2023.05.21链表的中间结点
  
• 瑞文考研算法每日一题—2023.5.20 反转链表
  
• 瑞文考研算法每日一题—2023.05.25 合并两个有序链表
  (这个条件更为严格，本题只需要依次合并即可)

细节：

  在链表的中间结点过程中，我们知道返回的是$\lfloor \frac{n}{2}\rfloor$ 下标的元素，n为链表长度。在上例中，返回的是$L4$，若我们需要拆分成两个链表，则需要将L4的前一个结点置空，这似乎需要额外的操作。理想的情况应该是返回 $L3$ ，将 $L3\to \varnothing$ 。

  当我们观察新的链表后发现，将链表拆分为$L1\to L2\to L3\to L4$，$L5\to L6$仍满足，因为$L4$是最后一个元素，它在链表一的尾部和反转后的链表二的尾部是等价的。

Code

/**
 * 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) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head){
        ListNode* slow = head, *fast = head->next;
        while(fast && fast->next){
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
    
    ListNode* reverseList(ListNode* head){
        if(head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode* res = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return res;
    }

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2){
        ListNode* dummy = new ListNode(), *cur = dummy;
        while(l1 || l2){
            if(l1){
                dummy->next = l1;
                dummy = dummy->next;
                l1 = l1->next;
            }
            if(l2){
                dummy->next = l2;
                dummy = dummy->next;
                l2 = l2->next;
            }
        }
        return dummy->next;
    }

    void reorderList(ListNode* head) {
        ListNode* mid = middleNode(head);
        ListNode* l2 = mid->next;
        mid->next = nullptr; //需要将第一部分链表的多余部分截断
        
        l2 = reverseList(l2);
        head = mergeTwoLists(head, l2);
    }
};

复杂度

• 时间复杂度:
  $O(n)$，$n$为链表长度。

• 空间复杂度:
  $O(1)$