[链表]18.重排链表[字节跳动]

题目：将给定的单链表\ L L： L_0→L_1→…→L_{n-1}→L_ nL0​→L1​→…→Ln−1​→Ln​
重新排序为：L_0→L_n →L_1→L_{n-1}→L_2→L_{n-2}→…L0​→Ln​→L1​→Ln−1​→L2​→Ln−2​→…
要求使用原地算法，不能改变节点内部的值，需要对实际的节点进行交换。
例如：
对于给定的单链表{10,20,30,40}，将其重新排序为{10,40,20,30}.

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

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

解题思路：

1. 先找到原链表的中间节点，然后切断中间节点与上一个节点的练习。
2. 反转原链表中间节点为头节点的链表。
3. 按照给定的重排方式将原链表与反转后的链表拼接起来。

//找到中间节点,进行断链
//
import java.util.*;
public class Solution {
    public void reorderList(ListNode head) {
        if (head == null || head.next == null) {
            return;
        }
        ListNode t = head;
        //先找到中间节点
        ListNode temp = findMidNode(head);
        ListNode midNode = temp.next;
        temp.next = null;
        //反转中间节点为头节点的链表
        midNode = reverseNode(midNode);
        //按照特定顺序将原链表的前一半与反转后的链表拼接起来
        ListNode newNode = new ListNode(-1);
        ListNode n = newNode;
        int flag = 1;
        while (t != null && midNode != null) {
            if(flag % 2 == 1) {
                n.next = t;
                t = t.next;
            }else {
                n.next = midNode;
                midNode = midNode.next;
            }
            flag++;
            n = n.next;
        }
        if (t == null && midNode != null) {
            n.next = midNode;
        }else if (t != null && midNode == null) {
            n.next = t;
        } 
        head = newNode.next;
    }
    //找到链表的中间节点的上一个节点
    private ListNode findMidNode(ListNode head) {
        ListNode f = head;
        ListNode s = head;
        while(f.next != null && f.next.next != null) {
            s = s.next;
            f = f.next.next;
        }
        return s;
    }
    //反转节点
    private ListNode reverseNode(ListNode head) {
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        ListNode f = head;
        ListNode s = f.next;
        while (s != null) {
            f.next = s.next;
            s.next = dummyHead.next;
            dummyHead.next = s;
            s = f.next;
        }
        return dummyHead.next;
    }
}