面试金典15（Python）—— 回文链表（简单）

回文链表

概述：编写一个函数，检查输入的链表是否是回文的。

输入： 1->2
输出： false 

输入： 1->2->2->1
输出： true 

方法一：列表+翻转

思路：建立一个空列表，遍历链表所有节点。最后对列表翻转判断即可。

# 列表+翻转
# 建立一个空列表，遍历链表所有节点。
# 最后对列表翻转判断即可。
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        stack = []
        while head != None:
            stack.append(head.val)
            head = head.next
        return stack == stack[::-1]

方法二：双指针

思路：该算法是经典的回文数算法。首先遍历链表，添加所有节点。然后定义左右（头尾）两个指针，对列表进行判断。若相等，范围缩小，若不等，返回即可。

# 双指针
# 该算法是经典的回文数算法。首先遍历链表，添加所有节点。
# 然后定义左右（头尾）两个指针，对列表进行判断。
# 若相等，范围缩小，若不等，返回即可。
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        stack = []
        while head != None:
            stack.append(head.val)
            head = head.next
        left = 0
        right = len(stack) - 1
        while left <= right:
            if stack[left] == stack[right]:
                left += 1
                right -= 1
            else:
                return False
        return True

方法三：栈

思路：该算法是回文数算法的另一种解法。依旧首先遍历链表，添加所有节点。然后对列表一半长度进行循环，若与最后一个值相等，弹出即可。

# 栈
# 该算法是回文数算法的另一种解法。依旧首先遍历链表，添加所有节点。
# 然后对列表一半长度进行循环，若与最后一个值相等，弹出即可。
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        stack = []
        while head != None:
            stack.append(head.val)
            head = head.next
        n = len(stack)
        if n == 0 or n == 1:
            return True
        i = 0
        while i <= (n // 2 - 1):
            if stack[i] == stack[-1]:
                stack.pop()
                i += 1
            else:
                return False
        return True

方法四：递归

思路：思路非常巧妙！定义一个递归函数，其中指针指向尾节点。函数外的指针指向头节点，然后依次递归判断即可。

# 递归
# 思路非常巧妙！定义一个递归函数，其中指针指向尾节点。
# 函数外的指针指向头节点，然后依次递归判断即可。
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        self.front_pointer = head
        def recursively_check(current_node = head):
            if current_node is not None:
                if not recursively_check(current_node.next):
                    return False
                if self.front_pointer.val != current_node.val:
                    return False
                self.front_pointer = self.front_pointer.next
            return True
        return recursively_check()

总结

快慢指针方法有点弄巧成拙了~