Leetcode - 143. Reorder List

最新推荐文章于 2024-05-29 08:09:48 发布

进阶的小蜉蝣

最新推荐文章于 2024-05-29 08:09:48 发布

阅读量201

点赞数

CC 4.0 BY-SA版权

文章标签：单链表

本文链接：https://blog.csdn.net/zqxf123456789/article/details/108041140

本文介绍了一种链表操作技巧，即将一个给定的单链表重新排序为交替模式，如1->2->3->4变为1->4->2->3。此方法通过两步实现：首先找到链表中点并逆置后半段；然后交错合并前半段与逆置后的后半段。无需修改节点值，完全在原地进行。示例包括4节点和5节点链表的转换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…

You may not modify the values in the list’s nodes, only nodes itself may be changed.
You must do this in-place without altering the nodes’ values.

Example 1:

Given 1->2->3->4, reorder it to 1->4->2->3.

Example 2:

Given 1->2->3->4->5, reorder it to 1->5->2->4->3.

Solution:

/**
 * 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:
    void reorderList(ListNode* head) {
        if(head == nullptr)
            return;
        
        ListNode* mid = head;
        ListNode* p = head;
        
        while(p && p->next)
        {
            mid = mid->next;
            p = p->next->next;
        }
        
        if(mid->next)
        {
            ListNode* pnew = reverse(mid->next); // 逆转后半部分
            mid->next = nullptr; // 截断两个链表
            
            p = head;
            while(p && pnew)  // 将逆转后的链表插入到前半部分链表
            {
                ListNode* tmp = p->next;
                p->next = pnew;
                pnew = pnew->next;
                p->next->next = tmp;
                p = p->next->next;
            }
        }
    }
    
private:
    ListNode* reverse(ListNode* head)
    {
        ListNode dummy{-1, head};
        ListNode* p = &dummy;
        ListNode* prev = p->next;
        ListNode* cur = prev->next;
        
        while(prev && cur)
        {
            prev->next = cur->next;
            cur->next = p->next;
            p->next = cur;
            
            cur = prev->next;
        }
        
        return dummy.next;
    }
};