链表题目：回文链表

题目

标题和出处

标题：回文链表

出处：234. 回文链表

难度

3 级

题目描述

要求

给你单链表的头结点 $\text{head}$，如果是回文链表，返回 $\text{true}$。

示例

示例 1：

输入：$\text{head = [1,2,2,1]}$
输出：$\text{true}$

示例 2：

输入：$\text{head = [1,2]}$
输出：$\text{false}$

数据范围

• 链表中结点的数目范围是 ${\text{[1, 10}}^{\text{5}}\text{]}$
• $\text{0}\le \text{Node.val}\le \text{9}$

进阶

你能否使用 $\text{O(n)}$ 时间和 $\text{O(1)}$ 空间解决这道题？

解法一

思路和算法

最直观的方法是用数组存储链表中的每个结点的值，然后判断数组中的元素是否构成回文。遍历链表，将每个结点的值依次加入数组 $\text{nums}$，此时数组中的元素顺序和链表的每个结点的值的顺序一致。

假设链表的结点数是 $\text{size}$，则数组 $\text{nums}$ 的长度也是 $\text{size}$。数组 $\text{nums}$ 中的元素构成回文，当且仅当对任意 $0\le i<\text{size}$ 都有 $\text{nums}[i]=\text{nums}[\text{size}-1-i]$。

在判断数组中的元素是否构成回文时，只需要考虑 $i<\text{size}-1-i$ 的情况，等价于 $i<\frac{\text{size}-1}{2}$。因此只需要对 $0\le i\le \lfloor \frac{\text{size}-1}{2}\rfloor$ 的情况判断对应元素是否相等即可。

代码

class Solution {
    public boolean isPalindrome(ListNode head) {
        List<Integer> nums = new ArrayList<Integer>();
        ListNode node = head;
        while (node != null) {
            nums.add(node.val);
            node = node.next;
        }
        int size = nums.size();
        for (int i = (size - 1) / 2; i >= 0; i--) {
            int j = size - 1 - i;
            if (nums.get(i) != nums.get(j)) {
                return false;
            }
        }
        return true;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是链表的长度。需要遍历链表中的每个结点一次，将结点值加入数组，然后需要遍历数组判断是否构成回文。

• 空间复杂度：$O(n)$，其中 $n$ 是链表的长度。需要创建长度为 $n$ 的数组存储链表中每个结点的值。

解法二

思路和算法

为了将空间复杂度降低到 $O(1)$，不能使用数组存储链表的结点值，而是需要将链表的一半反转，然后比较链表的前后两半是否相同。

为了将链表的一半反转，需要首先找到链表的中间结点。可以使用「链表的中间结点」的快慢指针的做法，使用 $O(1)$ 空间找到链表的中间结点，当链表的结点数是偶数时，得到的是链表的第二个中间结点。快慢指针遍历结束时，快指针 $\text{fast}$ 移动到链表的尾结点或者空结点，慢指针 $\text{slow}$ 移动到链表的中间结点。

链表的前一半为 $\text{slow}$ 前面的部分，不包含 $\text{slow}$，链表的后一半则由链表结点数的奇偶性决定：

• 当链表的结点数是奇数时，链表的后一半从 $\text{slow}.\text{next}$ 开始，此时链表的中间结点既不属于前一半也不属于后一半，其余每个结点都属于前一半或者后一半；

• 当链表的结点数是偶数时，链表的后一半从 $\text{slow}$ 开始，此时链表的每个结点都属于前一半或者后一半。

确定链表的前一半和后一半之后，将链表的前一半反转，即反转 $\text{slow}$ 前面的部分，反转的部分不包含 $\text{slow}$。反转链表的做法可以使用「反转链表」的迭代解法，使得空间复杂度为 $O(1)$。

将前一半反转之后，同时遍历链表的两半（注意前一半已经反转），则每次遍历到的两个结点为原始链表中关于中心对称的结点。当且仅当每次遍历到的两个结点的值相等时，原始链表是回文链表。

当链表结点数是奇数时，考虑如下链表：

$$1\to 2\to 3\to 2\to 1$$

将前一半反转之后变成：

$$1\leftarrow 23\to 2\to 1$$

分别从两个结点 $2$ 开始遍历链表的两半。

当链表结点数是偶数时，考虑如下链表：

$$1\to 2\to 3\to 3\to 2\to 1$$

将前一半反转之后变成：

$$1\leftarrow 2\leftarrow 33\to 2\to 1$$

分别从两个结点 $3$ 开始遍历链表的两半。

代码

class Solution {
    public boolean isPalindrome(ListNode head) {
        ListNode fast = head, slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        boolean odd = fast != null;
        ListNode firstHalfEnd = slow;
        ListNode secondHalfStart = odd ? slow.next : slow;
        ListNode node1 = reverseFirstHalf(head, firstHalfEnd);
        ListNode node2 = secondHalfStart;
        while (node1 != null) {
            if (node1.val != node2.val) {
                return false;
            }
            node1 = node1.next;
            node2 = node2.next;
        }
        return true;
    }

    public ListNode reverseFirstHalf(ListNode head, ListNode firstHalfEnd) {
        ListNode prev = null, curr = head;
        while (curr != firstHalfEnd) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是链表的长度。需要使用快慢指针遍历链表，遍历链表的前一半并反转，以及反转后遍历链表，每次遍历的时间复杂度都是 $O(n)$。

• 空间复杂度：$O(1)$。