Question

02.06. Palindrome Linked List

中文文档

Description

Implement a function to check if a linked list is a palindrome.

 

Example 1:

Input:  1->2

Output:  false

Example 2:

Input:  1->2->2->1

Output:  true

 

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

Solutions

Solution 1

# 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;
  }
}

func isPalindrome(head *ListNode) bool {
  if head == nil {
    return true
  }
  m := mid(head)
  temp := reverse(m.Next)
  m.Next = nil
  p, q := head, temp
  res := true
  for p != nil && q != nil {
    if p.Val != q.Val {
      res = false
      break
    }
    p = p.Next
    q = q.Next
  }
  m.Next = reverse(temp)
  return res
}

func mid(head *ListNode) *ListNode {
  slow, fast := head, head.Next
  for fast != nil && fast.Next != nil {
    slow = slow.Next
    fast = fast.Next.Next
  }
  return slow
}

func reverse(head *ListNode) *ListNode {
  var prev *ListNode = nil
  for head != nil {
    temp := head.Next
    head.Next = prev
    prev = head
    head = temp
  }
  return prev
}

/**
 * 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;
  }
}

Solution 2

/**
 * 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 root = head;
  const dfs = (node: ListNode | null): boolean => {
    if (node == null) {
      return true;
    }
    if (dfs(node.next) && node.val === root.val) {
      root = root.next;
      return true;
    }
    return false;
  };
  return dfs(head);
}