leetcode 探索 链表 回文链表

题目

请判断一个链表是否为回文链表。
示例 1:

输入: 1->2
输出: false

示例 2:

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

分析

这题有两个解法，

• 一是新建一个数组，将每个链表元素，加入到数组中，然后通过双指针，一个指向首，一个指向尾，依次比较，空间复杂度O(N), 时间复杂度O(N+N/2)
• 二是通过快慢指针，迅速定位到中心点，然后翻转中心点后的链表，然后将翻转后的链表与初始链表的从头开始比较。这是比较难以想到的解法。

解法

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func isPalindrome(head *ListNode) bool {
    if head == nil {
        return true
    }
    
    var space []int
    cur := head
    for cur != nil {
        space = append(space, cur.Val)
        cur = cur.Next
    }
    
    for i, j:=0, len(space)-1; i <= j; {
        if space[i] != space[j] {
            return false
        }
        i++
        j--
    }
    return true
}

• 解法2
  快慢指针法，迅速定位到中心点，然后翻转指针，再从头开始比较

/**
 * 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
    }
    
    mHead := &ListNode{
        Next: head,
    }
    
    // 快慢指针，快速找到中心点
    slow, fast := mHead.Next, mHead.Next.Next
    for fast != nil && fast.Next != nil {
        // fmt.Printf("slow:%v, fast: %v\n", slow, fast)
        slow = slow.Next
        fast = fast.Next.Next
    }
    // fmt.Printf("final slow: %v, fast: %v\n", slow, fast)
    // 如果是奇数个，那么slow 停在中心5/2=2, fast 为nil
    // 如果是偶数个，那么slow停在中心的左边，即6/2 - 1=2，fast不为nil
    
    slow = slow.Next
    
    nextHalfHead := reverse(slow)
    
    cur := head
    for nextHalfHead != nil {
        if cur.Val == nextHalfHead.Val {
            cur = cur.Next
            nextHalfHead = nextHalfHead.Next
        } else {
            return false
        }
    }
    
    return true
}

func reverse(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    
    // mprint(pre, "reversed before")
    
    var pre *ListNode
    cur := head
    for cur != nil {
        temp := cur.Next
        cur.Next = pre
        pre = cur
        cur = temp
    }
    // mprint(pre, "reversed after")
    return pre
}

func mprint(head *ListNode, msg string) {
    fmt.Print("%s :", msg)
    p := head
    for p != nil {
        fmt.Printf("%v \t", p)
        p = p.Next
    }
    fmt.Println("")
}