反转链表练习

【温馨提示】在阅读本文之前看一下 反转链表解释，阅读起来会更加容易哦~

24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

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

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

题目分析

仔细看呢，这道题其实和我们昨天写的 25. K个一组翻转链表 是一样的，无非就是把$k$改成了实际的数字2，所以代码如下：

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        int n = 0;
        ListNode dummy = new ListNode(0, head);
        ListNode cur = head;
        // 获取链表长度
        while(cur != null){
            cur = cur.next;
            n ++;
        }

        cur = head;
        ListNode pre = null;
        ListNode p0 = dummy;
        while(n >= 2){
            n -= 2;
            for(int i = 0; i < 2; i ++){
                ListNode nxt = cur.next;
                cur.next = pre;
                pre = cur;
                cur = nxt;
            }
            ListNode nxt = p0.next;
            p0.next.next = cur;
            p0.next = pre;
            p0 = nxt;
        }
        return dummy.next;
    }
}

复杂度分析

• 时间复杂度：由于代码中主要的操作是计算链表长度和两两交换节点，这两个操作的时间复杂度都是 (O(N))，所以整个函数的时间复杂度为 (O(N))。
• 空间复杂度：(O(1))，只使用了常数级的额外空间。

142. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

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

示例 1：

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

示例 2：

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

提示：

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

题目分析

根据题意，本题可以分为三个步骤：

1. 找到链表的中间节点：使用快慢指针法，快指针每次移动两步，慢指针每次移动一步。当快指针到达链表末尾时，慢指针刚好指向链表的中间节点。
2. 反转链表的后半部分：从中间节点的下一个节点开始，将链表的后半部分进行反转。
3. 合并前半部分链表和反转后的后半部分链表：将前半部分链表和反转后的后半部分链表交替合并，从而得到重排后的链表。

【注意！】记得在找到中间节点的时候，把前后两段链表分开，也就是将第一段链表的最后一个数指向null。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public void reorderList(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;

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

        // 断开前半部分链表和后半部分链表的连接
        ListNode secondHalf = slow.next;
        slow.next = null;

        ListNode cur = secondHalf;
        ListNode pre = null;

        while(cur != null){
            ListNode nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }
        
        ListNode firstHalf = head;
        secondHalf = pre;
        while(firstHalf != null && secondHalf != null){
            ListNode firstHalfNext = firstHalf.next;
            ListNode secondHalfNext = secondHalf.next;

            secondHalf.next = firstHalfNext;
            firstHalf.next = secondHalf;

            firstHalf = firstHalfNext;
            secondHalf = secondHalfNext;
        }
    }
}

复杂度分析

• 时间复杂度：(O(n))，其中 (n) 是链表的长度。找中间节点的时间复杂度是 (O(n/2))，反转后半部分链表的时间复杂度是 (O(n/2))，合并两个链表的时间复杂度是 (O(n))，总体时间复杂度为 (O(n))。
• 空间复杂度：(O(1))，只使用了常数级的额外空间。