LeetCode 143. 重排链表【模拟，链表】

最新推荐文章于 2025-01-17 16:06:48 发布

ln2037

最新推荐文章于 2025-01-17 16:06:48 发布

阅读量291

点赞数

分类专栏：模拟

本文链接：https://blog.youkuaiyun.com/ln2037/article/details/118033871

版权

模拟专栏收录该内容

45 篇文章

订阅专栏

本文介绍了一种链表重构算法，该算法将链表分为两半并反转后半部分，然后交错合并两部分以达到特定的排列顺序。通过示例展示了如何将链表1->2->3->4重新排列为1->4->2->3，以及更长链表的处理方式。

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

给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1:

给定链表 1->2->3->4, 重新排列为 1->4->2->3.
示例 2:

给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.

两种写法。
1.把链表转换为数组，根据数组重建链表。

2.从中间将链表分为两半，将后一半链表反转，然后将这两部分链表合并。

/**
 * 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* reverse(ListNode *root) {
        ListNode *pre = NULL, *cur = root;
        while(cur != NULL) {
            ListNode *nex = cur -> next;
            cur -> next = pre;
            pre = cur;
            cur = nex;
        }
        return pre;
    }

    void reorderList(ListNode* head) {
        ListNode *hair = new ListNode();
        hair -> next = head;
        ListNode *slow = hair, *fast = hair;
        while(fast != NULL && fast -> next != NULL && fast -> next -> next != NULL) {
            fast = fast -> next -> next;
            slow = slow -> next;
        }
        ListNode *l1= head, *l2 = slow -> next;
        slow -> next = NULL;
        ListNode *l3 = reverse(l2);
        while(l1 != NULL && l3 != NULL) {
            ListNode *n1 = l1 -> next, *n3 = l3 -> next;
            l1 -> next = l3;
            l3 -> next = n1;
            if(n1 == NULL) l3 -> next = n3;
            l1 = n1, l3 = n3;
        }
    }
};