关于leetcode:Golang力扣LeetBook初级算法链表回文链表快慢指针

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

链接：力扣 LeetBook—高级算法—链表—回文链表.

示例 1：

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

示例 2：

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

标签：栈、递归、链表、双指针

思路：

• 循环遍历链表，快指针每次走两个节点，慢指针每次走一个节点，当快指针遍历完链表，慢指针停下的地位就是中心点。（因为快指针从第二个节点开始走，所以不须要思考奇偶的状况）
• 当找到中心点后，把慢指针走过的节点从头到中心点截断，为待比拟的第一局部链表。
• 将从中心点到链表结尾的局部所有节点进行倒序操作。作为待比拟的第二局部链表。
• 比拟两个链表每个节点是否相等，如果相等则为回文。

次要 Go 代码如下：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func isPalindrome(head *ListNode) bool {
    if head == nil || head.Next == nil {return true}
    fast := head.Next // 快指针，从第二个开始，能够解决奇偶问题
    slow := head      // 慢指针
    
    // 因为快指针从第二个节点开始走，所以不须要思考奇偶的状况。for fast != nil && fast.Next != nil {
        fast = fast.Next.Next // 快指针每次走两个节点
        slow = slow.Next      // 慢指针每次走一个节点
    }
    // 当快指针遍历完链表，慢指针停下的地位就是中心点
    cur := slow.Next // 保留前面还没有遍历的链表
    slow.Next = nil  // 将整个列表进行截断，保留为第一个链表

    p := reverseLink(cur) // 将前面的链表倒序

    // 比拟两个链表
    for p != nil && head != nil {
        if p.Val != head.Val {return false}
        p = p.Next
        head = head.Next
    }
    return true
}

// reverseLink 将链表倒序
func reverseLink(listHead *ListNode) *ListNode {
    if listHead == nil && listHead.Next == nil {return listHead}

    p := listHead     // 遍历链表的指针
    var rst *ListNode // 保留最初后果链表的指针
    var q *ListNode   // 保留下一个节点的长期指针

    for p != nil {
        q = p.Next
        p.Next = rst
        rst = p
        p = q
    }
    return rst
}

提交截图：

官网解答：
看了官网解答后豁然开朗，官网这种办法太简略了，它用了将值复制到数组中后用双指针法
步骤：1、复制链表值到数组列表中。2、应用双指针法判断是否为回文。

func isPalindrome(head *ListNode) bool {vals := []int{}
    for ; head != nil; head = head.Next {vals = append(vals, head.Val)
    }
    n := len(vals)
    for i, v := range vals[:n/2] {if v != vals[n-1-i] {return false}
    }
    return true
}