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);//递归调用函数完成对后续节点的处理
} 方法三:(高效)利用反转法,中间值.进行插入
思路
- 利用快慢指针法,求出链表的中间节点
- 得到两个子链标后,将最后一个反转
- 然后将子链表中的节点依次进行连接,得出的结果
有关合并的解图
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;
}
}
}