LeetCode 143. 重排链表【c++/Java详细题解】「这是我参与2022首次更文挑战的第31天，活动详情查看

「这是我参与2022首次更文挑战的第31天，活动详情查看：2022首次更文挑战」

1、题目

给定一个单链表 $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.

2、思路

(链表，模拟) $O(n)$

假设初始的链表是 $L1→L2→L3→…→Ln$ 。在这里插入图片描述分两步处理：

找到链表的中点节点，将其后半段的指针都反向，变成： $L1→L2→L3→…→L⌈n/2⌉←L⌈n/2⌉+1←…←Ln$ ;
用两个指针分别从1和n开始往中间扫描，将后半段交替插入到前半段，变成：

$L1→Ln→L2→Ln−1→L3→Ln-2…$ ;
这里有几个需要注意的点：

我们选取链表的中点节点为 $(n+1)/2$ 下取整， $n$ 是链表的节点个数。
我们将链表的中点节点划分到链表的前半段。
具体实现细节见代码详解。

如何将两个链表交错合并到一块？ 在这里插入图片描述进行完后半段链表的反向之后，a指向后半段链表的首部。

1、先让a指向head->next，即a->next = head->next;
2、然后head指向a，即 head->next = a;
3、head在合并完的链表上后移两个位置，a后移一个位置，重复上述过程。

时间复杂度分析: 整个链表总共扫描三次，第一次求总长度，第二次将后半段反向，第三次将后半段交替插入前半段，所以总时间复杂度是 $O(n)$ 。

3、c++代码

/**
 * 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) {
        int n = 0; //统计链表的节点个数
        for(ListNode *p = head; p; p = p->next) n++;
        if(n <= 2) return ; //如果链表的节点个数小于等于2，就没有重新排列的必要了
        ListNode *cur = head; 
        //找到中点节点，由第一个节点跳(n+1)/2 -1步到达中点节点
        for(int i = 0; i < (n+1)/2 -1; i++ ) cur = cur->next; 
        ListNode *a = cur; //a指针指向链表中点
        ListNode *b = cur->next; //b指针指向链表中点的下一个节点
        
        while(b) //将链表的后半段反向
        {
            ListNode *next = b->next; //保留b的next节点
            b->next = a;
            a = b, b = next;
        }
        cur->next = 0; //给前半段链表添加一个结束标记
        ListNode *tmp;
        while(head && head != a)//一个是遇到中点停止，一个是head, a左右两指针相遇停止
        {
            tmp = a->next;
            a->next = head->next;
            head->next = a;
            head = head->next->next;
            a = tmp;
        }
    }
};

4、Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head)
    {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null)
        {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    public ListNode reverse(ListNode head)
    {
        if(head == null || head.next == null) return head;
        ListNode tail = reverse(head.next);
        head.next.next = head;
        head.next = null;
        return tail;
    }
    public ListNode merge(ListNode left,ListNode right)
    {
        ListNode dummy = new ListNode(0);
        ListNode t = dummy;
        while(left != null && right != null)
        {
            t.next = left;
            t = t.next;
            left = left.next;

            t.next = right;
            t = t.next;
            right = right.next;
        }
        if(left != null) {t.next = left ; t = t.next; left = left.next;}
        if(right != null) {t.next = right ; t = t.next; right = right.next;}
        return dummy.next;
    }
    public void reorderList(ListNode head) {
        if(head == null) return ;

        ListNode middle = middleNode(head);

        ListNode left = head;
        ListNode right = reverse(middle.next);
        middle.next = null;

        head = merge(left,right);
    }
}