题目

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

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

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

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

提示：链表 L 的长度范围为 [1, 105]

0 <= node.val <= 9

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

注意：本题与主站 234 题相同

解题思路分析

1、数组辅助；时间复杂度O(n)，空间复杂度O(n)

func isPalindrome(head *ListNode) bool {
   m := make([]int, 0)
   for head != nil {
      m = append(m, head.Val)
      head = head.Next
   }
   i, j := 0, len(m)-1
   for i < j {
      if m[i] != m[j] {
         return false
      }
      i++
      j--
   }
   return true
}

2、快慢指针+反转链表；时间复杂度O(n)，空间复杂度O(1)

func isPalindrome(head *ListNode) bool {
   fast, slow := head, head
   for fast != nil && fast.Next != nil {
      fast = fast.Next.Next
      slow = slow.Next
   }
   var pre *ListNode
   cur := slow
   for cur != nil {
      next := cur.Next
      cur.Next = pre
      pre = cur
      cur = next
   }
   for pre != nil {
      if head.Val != pre.Val {
         return false
      }
      pre = pre.Next
      head = head.Next
   }
   return true
}

3、栈辅助；时间复杂度O(n)，空间复杂度O(n)

func isPalindrome(head *ListNode) bool {
   m := make([]int, 0)
   temp := head
   for temp != nil {
      m = append(m, temp.Val)
      temp = temp.Next
   }
   for head != nil {
      val := m[len(m)-1]
      m = m[:len(m)-1]
      if head.Val != val {
         return false
      }
      head = head.Next
   }
   return true
}

4、递归；时间复杂度O(n)，空间复杂度O(n)

var p *ListNode

func isPalindrome(head *ListNode) bool {
   if head == nil {
      return true
   }
   if p == nil {
      p = head
   }
   // 关键在于head因为递归的特性是从后往前比较
   // p是从前往后比较
   if isPalindrome(head.Next) && (p.Val == head.Val) {
      p = p.Next
      return true
   }
   p = nil
   return false
}

总结

Easy题目，题目同leetcode 234.回文链表、面试题02.06.回文链表