LeetCode 234. 回文链表（golang实现）

经典的链表问题

判断一个链表是否为回文链表。

• 示例 1:

输入: 1->2
输出: false
复制代码

• 示例 2:

输入: 1->2->2->1
输出: true
复制代码

这里使用golang耍一遍，原理是一样，语言只是其次。

使用快慢指针解决

1. 慢指针 指向头部
2. 快指针 指向第二个节点
3. 循环遍历链表，快指针每次走两个节点，慢指针每次走一个节点，当快指针遍历完链表，慢指针挺下的位置就是中心点，因为快指针从第二个节点开始走，所以不需要考虑奇偶的情况。
4. 当找到中心点后，把慢指针走过的节点从头到中心点截断，为待比较的第一部分链表
5. 将从中心点到链表结尾的部分所有节点进行倒序操作，也就是链表的倒序。作为待比较的第二部分链表
6. 比较两个链表每个节点是否相等，如果相等则为回文

/**
 * 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
	}
	lat := head.Next // 快指针，为什么从第二个开始，是为了解决奇偶问题
	pre := head      // 慢指针
	for lat != nil && lat.Next != nil {
		lat = lat.Next.Next
		pre = pre.Next
	}

	cur := pre.Next // 保留后面还没有遍历的链表
	pre.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
}
复制代码

完全使用链表操作就可以将空间复杂度降到O(1)。

转载于:https://juejin.im/post/5c6276a66fb9a04a0b22a7f4