LC143-重排链表

143. 重排链表

难度中等459收藏分享切换为英文接收动态反馈

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

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

示例 1:

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

示例 2:

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

方法一:储存到线性表.

单链表不能由尾部开始遍历取数,只能有头开始遍历,

因此将所有遍历出来,储存到线性表中,

通过前后双指针进行连接,得到结果

public void reorderList(ListNode head) {
    if (head == null) {
        return;
    }
    //存到 list 中去
    List<ListNode> list = new ArrayList<>();
    while (head != null) {
        list.add(head);
        head = head.next;
    }
    //头尾指针依次取元素
    int i = 0, j = list.size() - 1;
    while (i < j) {
        list.get(i).next = list.get(j);
        i++;
        //偶数个节点的情况，会提前相遇
        if (i == j) {
            break;
        }
        list.get(j).next = list.get(i);
        j--;
    }
    list.get(i).next = null;
}

方法二,(低效)整体进行递归

具体思路如图所示

    public void reorderList(ListNode head) {
            if(head==null||head.next==null||head.next.next==null)
        //当节点为空/节点是链表中的最后一个节点/倒数第二个节点时----说明不用再遍历下去了，直接返回
            return;
        ListNode temp=head;
        while(temp.next.next!=null)//找到倒数第二个节点
            temp=temp.next;
        temp.next.next=head.next;//将最后一个节点指向temp的后一个节点
        head.next=temp.next;//将head指向最后一个节点
        temp.next=null;//将倒数第二个节点的next指针域置空
        reorderList(head.next.next);//递归调用函数完成对后续节点的处理

    }

方法三:(高效)利用反转法,中间值.进行插入

思路

1. 利用快慢指针法,求出链表的中间节点
2. 得到两个子链标后,将最后一个反转
3. 然后将子链表中的节点依次进行连接,得出的结果

有关合并的解图

public void reorderList1(ListNode head) {
        if (head == null || head.next == null || head.next.next == null) {
            return;
        }
        // 1. 找中点，让slow指向中点，或左中点位置
        ListNode slow = head, fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        // 2. 断开中点，反转后半部分
        ListNode head2 = null, next = slow.next;
        slow.next = null;
        slow = next;
        while (slow != null) {
            next = slow.next;
            slow.next = head2;
            head2 = slow;
            slow = next;
        }
        // 3. 合并链表head和head2
        ListNode curr = head;
        ListNode curr2 = head2;
        while (curr != null && curr2 != null) {
            next = curr.next;
            curr.next = curr2;
            curr2 = curr2.next;
            curr.next.next = next;
            curr = next;
        }
    }

相对于其他递归的解法

class Solution {
    public void reorderList(ListNode head) {
        if(head == null){
            return ;
        }
        //1. 使用快慢指针,找出链表的中心节点。
        // 1->2->3->4->5,中心节点为3
        ListNode middle = middleNode(head);

        //2. 将原始链表按照中心链表分割为两个链表，并将右链表反转
        //2.1 原始链表：1->2->3->4->5 左链表：1->2->3 右链表：4->5
        ListNode left = head;
        ListNode right = middle.next;
        middle.next = null;

        //2.2 反转右链表
        //原始右链表：4->5 反转后：5->4
        right = reverse(right);

        //3. 合并两个链表，将右链表插入到左链表
        //左链表：1->2->3 右链表：4->5 合并后：1->5->2->4->3
        merge(left,right);
    }

    //1. 使用快慢指针,找出链表的中心节点
    public ListNode middleNode(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    //2. 通过递归反转链表
    public ListNode reverse(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode last = reverse(head.next);
        head.next.next = head;
        head.next = null;
        return last;
    }

    //3. 合并两个链表，将右链表插入到左链表
    public void merge(ListNode left, ListNode right){
        ListNode leftTemp;
        ListNode rightTemp;
        while (left.next != null && right!= null) {
            //1. 保存next节点
            leftTemp = left.next;
            rightTemp = right.next;

            //2. 将右链表的第一个节点插入到左链表中
            // 左链表：1->2->3 右链表：5->4 
            // 合并后的左链表：1->5->2->3 
            left.next = right;
            right.next = leftTemp;

            //3. 移动left和right指针
            //左链表变为：2->3 右链表变为：4
            left = leftTemp;
            right = rightTemp;
        }
    }
}