[LeetCode] 234. Palindrome Linked List

Given the head of a singly linked list, return true if it is a palindrome.

Example 1:

Input: head = [1,2,2,1]
Output: true

Example 2:

Input: head = [1,2]
Output: false

Constraints:

• The number of nodes in the list is in the range [1, 105].
• 0 <= Node.val <= 9

Follow up: Could you do it in O(n) time and O(1) space?

回文链表。

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

题意是给一个链表，判断是不是回文链表。思路是快慢指针找到链表中点，reverse后半段，然后比较前半和后半。题目要求不能使用额外空间。

二刷的时候有一个疑问，找到的链表中点，如果整个链表的节点数为奇数，中点在哪？节点数为偶数，中点又在哪？我跑了一个例子帮助加强记忆，如下图，图中数字表示节点的index。当找中间节点的函数跑完的时候，如果节点数是偶数个，则s停在3的位置；如果节点数是奇数个，则s停在2的位置。后半部分的head节点是slow.next所以后半部分的head节点分别是4和3（偶数，奇数）。

reverse后半部分，则对于第一个例子，比较的是123和654两个链表；对于第二个例子，比较的是12和543两个链表。又因为while循环的时候判断的是两个链表同时不为空，所以当链表节点个数为奇数的时候，也能判断input是否为回文链表。

1 - 2 - 3 - 4 - 5 - 6

s    f

1 - 2 - 3 - 4 - 5

s    f

时间O(n) - 题目要求

空间O(1) - 题目要求

JavaScript实现

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var isPalindrome = function(head) {
    if (head === null) return true;
    let middle = findMiddle(head);
    middle.next = reverse(middle.next);

    let p = head;
    let q = middle.next;
    while (p !== null && q !== null) {
        if (p.val !== q.val) {
            return false;
        }
        p = p.next;
        q = q.next;
    }
    return true;
};

var findMiddle = function(head) {
    let slow = head;
    let fast = head.next;
    while (fast !== null && fast.next !== null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}

var reverse = function(head) {
    let pre = null;
    while (head !== null) {
        let next = head.next;
        head.next = pre;
        pre = head;
        head = next;
    }
    return pre;
}

最后注意代码里面24行定义fast pointer的方式。

 

Java实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        // corner case
        if (head == null) {
            return true;
        }
        // normal case
        ListNode middle = findMiddle(head);
        middle.next = reverse(middle.next);
        ListNode p1 = head;
        ListNode p2 = middle.next;
        while (p1 != null && p2 != null) {
            if (p1.val != p2.val) {
                return false;
            } else {
                p1 = p1.next;
                p2 = p2.next;
            }
        }
        return true;
    }

    private ListNode findMiddle(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;
    }

    private ListNode reverse(ListNode head) {
        ListNode pre = null;
        while (head != null) {
            ListNode next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }
}

 

相关题目

125. Valid Palindrome

234. Palindrome Linked List

680. Valid Palindrome II

2130. Maximum Twin Sum of a Linked List

LeetCode 题目总结