Question

剑指 Offer II 027. 回文链表

题目描述

给定一个链表的 头节点 head ，请判断其是否为回文链表。

如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。

 

示例 1：

输入: head = [1,2,3,3,2,1]
输出: true

示例 2：

输入: head = [1,2]
输出: fasle

 

提示：

• 链表 L 的长度范围为 [1, 105]
• 0 <= node.val <= 9

 

进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

 

注意：本题与主站 234 题相同：https://leetcode.cn/problems/palindrome-linked-list/

解法

方法一

# Definition for singly-linked list.
# class ListNode:
#   def __init__(self, val=0, next=None):
#     self.val = val
#     self.next = next
class Solution:
  def isPalindrome(self, head: ListNode) -> bool:
    if head is None or head.next is None:
      return True
    slow, fast = head, head.next
    while fast and fast.next:
      slow, fast = slow.next, fast.next.next
    pre, cur = None, slow.next
    while cur:
      t = cur.next
      cur.next = pre
      pre, cur = cur, t
    while pre:
      if pre.val != head.val:
        return False
      pre, head = pre.next, head.next
    return True

/**
 * 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 boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) {
      return true;
    }
    ListNode slow = head;
    ListNode fast = head.next;
    while (fast != null && fast.next != null) {
      slow = slow.next;
      fast = fast.next.next;
    }
    ListNode cur = slow.next;
    slow.next = null;
    ListNode pre = null;
    while (cur != null) {
      ListNode t = cur.next;
      cur.next = pre;
      pre = cur;
      cur = t;
    }
    while (pre != null) {
      if (pre.val != head.val) {
        return false;
      }
      pre = pre.next;
      head = head.next;
    }
    return true;
  }
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *   int val;
 *   ListNode *next;
 *   ListNode() : val(0), next(nullptr) {}
 *   ListNode(int x) : val(x), next(nullptr) {}
 *   ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
  bool isPalindrome(ListNode* head) {
    if (!head || !head->next) return true;
    ListNode* slow = head;
    ListNode* fast = head->next;
    while (fast && fast->next) {
      slow = slow->next;
      fast = fast->next->next;
    }
    ListNode* pre = nullptr;
    ListNode* cur = slow->next;
    while (cur) {
      ListNode* t = cur->next;
      cur->next = pre;
      pre = cur;
      cur = t;
    }
    while (pre) {
      if (pre->val != head->val) return false;
      pre = pre->next;
      head = head->next;
    }
    return true;
  }
};

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *   Val int
 *   Next *ListNode
 * }
 */
func isPalindrome(head *ListNode) bool {
  if head == nil || head.Next == nil {
    return true
  }
  slow, fast := head, head.Next
  for fast != nil && fast.Next != nil {
    slow, fast = slow.Next, fast.Next.Next
  }
  var pre *ListNode
  cur := slow.Next
  for cur != nil {
    t := cur.Next
    cur.Next = pre
    pre = cur
    cur = t
  }
  for pre != nil {
    if pre.Val != head.Val {
      return false
    }
    pre, head = pre.Next, head.Next
  }
  return true
}

/**
 * Definition for singly-linked list.
 * class ListNode {
 *   val: number
 *   next: ListNode | null
 *   constructor(val?: number, next?: ListNode | null) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 *   }
 * }
 */

function isPalindrome(head: ListNode | null): boolean {
  if (head == null || head.next == null) return true;
  // 快慢指针定位到中点
  let slow: ListNode = head,
    fast: ListNode = head.next;
  while (fast != null && fast.next != null) {
    slow = slow.next;
    fast = fast.next.next;
  }
  // 翻转链表
  let cur: ListNode = slow.next;
  slow.next = null;
  let prev: ListNode = null;
  while (cur != null) {
    let t: ListNode = cur.next;
    cur.next = prev;
    prev = cur;
    cur = t;
  }
  // 判断回文
  while (prev != null) {
    if (prev.val != head.val) return false;
    prev = prev.next;
    head = head.next;
  }
  return true;
}

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *   this.val = (val===undefined ? 0 : val)
 *   this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {boolean}
 */
var isPalindrome = function (head) {
  if (!head || !head.next) {
    return true;
  }
  let slow = head;
  let fast = head.next;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
  }
  let cur = slow.next;
  slow.next = null;
  let pre = null;
  while (cur) {
    let t = cur.next;
    cur.next = pre;
    pre = cur;
    cur = t;
  }
  while (pre) {
    if (pre.val !== head.val) {
      return false;
    }
    pre = pre.next;
    head = head.next;
  }
  return true;
};

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *   public int val;
 *   public ListNode next;
 *   public ListNode(int val=0, ListNode next=null) {
 *     this.val = val;
 *     this.next = next;
 *   }
 * }
 */
public class Solution {
  public bool IsPalindrome(ListNode head) {
    if (head == null || head.next == null)
    {
      return true;
    }
    ListNode slow = head;
    ListNode fast = head.next;
    while (fast != null && fast.next != null)
    {
      slow = slow.next;
      fast = fast.next.next;
    }
    ListNode cur = slow.next;
    slow.next = null;
    ListNode pre = null;
    while (cur != null)
    {
      ListNode t = cur.next;
      cur.next = pre;
      pre = cur;
      cur = t;
    }
    while (pre != null)
    {
      if (pre.val != head.val)
      {
        return false;
      }
      pre = pre.next;
      head = head.next;
    }
    return true;
  }
}