LeetCode(力扣) 234题：回文链表----三种方法求解附带详细注释

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

示例

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

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

思路分析
看到这道题，相信很多朋友跟我一样，就想把链表里的元素放在列表里，然后判断列表是否为回文链表。当然这是第一种最简单直观容易想到的方法。
但是有没有其他方法？能不能像证明回文字符串那样，采用双指针的方法来解决回文链表的问题呢？答案是可以的，但是需要用到递归的方法将链表的节点按照顺序压入栈中，栈中的节点相当于右指针，在这里右指针的移动方式是靠栈的弹出来实现的，大家细品，再设置一个外部节点，该外部节点相当于左指针，其移动方式与正常指针无异。
我们都知道，栈是要耗费内存的，那么有没有办法减少内存的消耗呢？这里的解决办法是将链表分为前后两部分，然后把链表后半部分进行反转，反转之后与第二部分进行配准，如果完全一样，则是回文链表，否则不是。这种方法其实用到了很多知识点，比较有意思的是使用快慢指针来对链表进行前后两部分的划分，其次就是链表反转的知识点。

下边分别看一下这三种方法的代码。

代码展示

1、存进列表再判断

class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        #链表节点存入列表，判断列表是否是回文字串
        nodes = []
        #按顺序一次遍历列表节点，并存入列表nodes
        while head:
            nodes.append(head.val)
            head = head.next
        #判断列表
        for i in range(len(nodes)):
            if nodes[i] != nodes[len(nodes)-i-1]:
                return False
        return True

运行结果

2、递归(类比双指针)

class Solution:
	#定义外部指针节点
	self.front_node = head
	#递归函数，通过判断当前节点是否为空，将所有节点压入栈内
	#压入完毕之后，一次弹出与外部节点指针一次对比
    def func(current_node):
        if current_node:
            if not func(current_node.next): return False
            if current_node.val != self.front_node.val: return False
            self.front_node = self.front_node.next
        return True #base case，最后一个节点返回True，用于栈内元素的弹出
    ans = func(head)
    return ans

运行结果

3、快慢指针，链表分半

    #快慢指针#
        #先使用快慢指针找到链表的前半部分和后半部分
        #对后半部分链表进行反转
        #对比前半部分与反转过的后半部分是否相同
        #比较之后再将后半部分反转过来

        #考虑链表为空的情况
        if not head:
            return True
        #快慢指针分离链表，并返回第二部分的起始节点
        def seperate_linkList(node):
            fast, slow = node, node
            while fast.next and fast.next.next:
                slow = slow.next
                fast = fast.next.next
            return slow #返回第一部分的终止节点
        #链表反转
        def reverse_ll(node):
            previous = None
            cur = node
            while cur:
                next_node = cur.next
                cur.next = previous
                previous = cur
                cur = next_node
            return previous

        first_half_end = seperate_linkList(head)
        second_half_start = reverse_ll(first_half_end.next)

        # 判断是否回文
        result = True
        first_position = head
        second_position = second_half_start
        while result and second_position is not None:
            if first_position.val != second_position.val:
                result = False
            first_position = first_position.next
            second_position = second_position.next        
        return result

运行结果

总结
在这片博客中，我们主要分析了回文链表这道题目，虽然只是一道简单题，但是在做题的时候要保持发散思维，今天使用三种方法从不同角度对空间复杂度和时间复杂度进行优化，并且还对递归、快慢指针、链表反转等知识进行了复盘。希望大家看完之后能有所启发~欢迎评论区交流。