返回介绍

solution / 0200-0299 / 0234.Palindrome Linked List / README

发布于 2024-06-17 01:04:03 字数 6909 浏览 0 评论 0 收藏 0

234. 回文链表

English Version

题目描述

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

 

示例 1:

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

示例 2:

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

 

提示:

  • 链表中节点数目在范围[1, 105]
  • 0 <= Node.val <= 9

 

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

解法

方法一:快慢指针

我们可以先用快慢指针找到链表的中点,接着反转右半部分的链表。然后同时遍历前后两段链表,若前后两段链表节点对应的值不等,说明不是回文链表,否则说明是回文链表。

时间复杂度 $O(n)$,空间复杂度 $O(1)$。其中 $n$ 为链表的长度。

# 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: Optional[ListNode]) -> bool:
    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) {
    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) {
    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 {
  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 {
  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) {
  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) {
    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;
  }
}

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。
列表为空,暂无数据
    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
    原文