LeetCode_双指针_中等_143.重排链表

比眉伴天荒 2023-10-14 10:13 21阅读 0赞

#### 目录 ####

*  1.题目
 *  2.思路
 *  3.代码实现（Java）

## 1.题目 ##

给定一个单链表 L 的头节点 head ，单链表 L 表示为：  
L0 → L1 → … → Ln-1 → Ln

请将其重新排列后变为：  
L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

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

**示例 1：**

![在这里插入图片描述][0d71678ed765494c8ac8d542b5912322.png]  
输入：head = \[1,2,3,4\]  
输出：\[1,4,2,3\]

**示例 2：**

![在这里插入图片描述][df93ed59f07f4c82ac9a18543549cca7.png]

输入：head = \[1,2,3,4,5\]  
输出：\[1,5,2,4,3\]

**提示：**  
链表的长度范围为 \[1, 5 \* 104\]  
1 <= node.val <= 1000

## 2.思路 ##

（1）线性表存储节点  
因为链表不支持下标访问，所以我们无法随机访问链表中任意位置的元素。比较容易想到的一个方法是，利用线性表存储该链表，然后利用线性表可以下标访问的特点，直接按顺序访问指定元素，重建该链表即可。

（2）寻找链表中点 & 翻转链表 & 合并链表  
注意到目标链表即为将原链表的左半端和反转后的右半端合并后的结果。这样我们的任务即可划分为三步：

*  找到原链表的中点（参考[876.链表的中间结点][876.]）：我们可以使用快慢指针来 O(N) 地找到链表的中间节点。
 *  将原链表的右半端反转（参考 [206.反转链表][206.]）：我们可以使用迭代法实现链表的反转。
 *  将原链表的两端合并：因为两链表长度相差不超过 1，因此直接合并即可。

相关题目：  
[LeetCode\_双指针\_简单\_876.链表的中间结点][876.]  
[LeetCode\_双指针\_递归\_简单\_206.反转链表][206.]

## 3.代码实现（Java） ##

//思路1————线性表存储节点
    class Solution {
        
        public void reorderList(ListNode head) {
        
            if (head == null) {
        
                return;
            }
            //使用 list 存储链表中的所有节点
            List<ListNode> list = new ArrayList<ListNode>();
            ListNode node = head;
            while (node != null) {
        
                list.add(node);
                node = node.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;
        }
    }

//思路2————寻找链表中点 & 翻转链表 & 合并链表
    class Solution {
        
        public void reorderList(ListNode head) {
        
            if (head == null) {
        
                return;
            }
            ListNode mid = middleNode(head);
            ListNode l1 = head;
            ListNode l2 = mid.next;
            mid.next = null;
            l2 = reverseList(l2);
            mergeList(l1, l2);
        }
    
        //寻找链表 head 的中间节点
        public ListNode middleNode(ListNode head) {
        
            ListNode slow = head;
            ListNode fast = head;
            while (fast.next != null && fast.next.next != null) {
        
                slow = slow.next;
                fast = fast.next.next;
            }
            return slow;
        }
    
        //翻转链表 head
        public ListNode reverseList(ListNode head) {
        
            ListNode prev = null;
            ListNode curr = head;
            while (curr != null) {
         
                ListNode next = curr.next;
                curr.next = prev;
                prev = curr;
                curr = next;
            }
            return prev;
        }
    
        //合并链表 l1 和 l2
        public void mergeList(ListNode l1, ListNode l2) {
        
            ListNode l1_tmp;
            ListNode l2_tmp;
            while (l1 != null && l2 != null) {
        
                l1_tmp = l1.next;
                l2_tmp = l2.next;
                l1.next = l2;
                l1 = l1_tmp;
                l2.next = l1;
                l2 = l2_tmp;
            }
        }
    }

[0d71678ed765494c8ac8d542b5912322.png]: https://img-blog.csdnimg.cn/0d71678ed765494c8ac8d542b5912322.png
[df93ed59f07f4c82ac9a18543549cca7.png]: https://img-blog.csdnimg.cn/df93ed59f07f4c82ac9a18543549cca7.png
[876.]: https://xgqngu.blog.csdn.net/article/details/122726393
[206.]: https://xgqngu.blog.csdn.net/article/details/124894199