用go构建-回文链表

目录

题目

算法思路

代码

代码详解

1. 边界处理

2. 快慢指针找中点

3. 反转后半部分链表

4. 比较前后两部分

---

题目

​​​​​234. 回文链表

简单

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

示例 1：

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

示例 2：

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

提示：

• 链表中节点数目在范围[1, 105] 内
• 0 <= Node.val <= 9

进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

算法思路

核心思想：反转后半部分链表进行比较

主要步骤：

1. 找到中间节点（使用快慢指针）

   • 慢指针每次走一步，快指针每次走两步

   • 当快指针到达末尾时，慢指针在中间位置

2. 反转后半部分链表

   • 从中间节点开始反转链表后半部分

3. 比较前后两部分

   • 分别从头节点和反转后的后半部分头节点开始比较

   • 逐个节点比较值是否相等

代码

package main
import "fmt"
// 链表节点定义
type ListNode struct {Val  intNext *ListNode
}
// 解法：反转后半部分链表（O(1)空间复杂度）
func isPalindrome(head *ListNode) bool {if head == nil || head.Next == nil {return true}// 1. 快慢指针找中点slow, fast := head, headfor fast != nil && fast.Next != nil {slow = slow.Nextfast = fast.Next.Next}// 2. 反转后半部分var prev *ListNodecur := slowfor cur != nil {next := cur.Nextcur.Next = prevprev = curcur = next}// 3. 比较前后两部分p1, p2 := head, prevfor p2 != nil {if p1.Val != p2.Val {return false}p1 = p1.Nextp2 = p2.Next}return true
}
// 创建测试链表
func createList(nums []int) *ListNode {if len(nums) == 0 {return nil}head := &ListNode{Val: nums[0]}cur := headfor i := 1; i < len(nums); i++ {cur.Next = &ListNode{Val: nums[i]}cur = cur.Next}return head
}
// 测试函数
func main() {// 测试用例tests := []struct {nums     []intexpected bool}{{[]int{1, 2, 2, 1}, true},   // 示例1{[]int{1, 2}, false},         // 示例2{[]int{1}, true},             // 单节点{[]int{}, true},              // 空链表{[]int{1, 2, 3, 2, 1}, true}, // 奇数长度回文{[]int{1, 2, 3, 4}, false},   // 非回文{[]int{1, 1}, true},          // 两节点相同{[]int{1, 2, 1}, true},       // 三节点回文}// 运行测试for i, test := range tests {head := createList(test.nums)result := isPalindrome(head)if result == test.expected {fmt.Printf("测试用例 %d ✓: %v -> %v\n", i+1, test.nums, result)} else {fmt.Printf("测试用例 %d ✗: %v -> %v (期望 %v)\n", i+1, test.nums, result, test.expected)}}
}

func isPalindrome(head *ListNode) bool {if head == nil || head.Next == nil {return true}// 快慢指针找中点slow, fast := head, headfor fast != nil && fast.Next != nil {slow = slow.Nextfast = fast.Next.Next}// 反转后半部分var prev *ListNodecur := slowfor cur != nil {next := cur.Nextcur.Next = prevprev = curcur = next}// 比较前后两部分p1, p2 := head, prevfor p2 != nil {if p1.Val != p2.Val {return false}p1 = p1.Nextp2 = p2.Next}return true
}

代码详解

1. 边界处理

go

if head == nil || head.Next == nil {return true
}

• head == nil：空链表，没有节点，视为回文

• head.Next == nil：只有一个节点，如 [1]，也是回文

• 这两种情况直接返回 true

2. 快慢指针找中点

go

slow, fast := head, head
for fast != nil && fast.Next != nil {slow = slow.Nextfast = fast.Next.Next
}

快慢指针原理：

• slow 慢指针：每次走 1 步

• fast 快指针：每次走 2 步

• 当 fast 到达末尾时，slow 正好在中间

示例说明：

text

链表: 1 -> 2 -> 3 -> 2 -> 1初始: slow=1, fast=1
第1次: slow=2, fast=3
第2次: slow=3, fast=1
结束: slow指向3（中间节点）链表: 1 -> 2 -> 2 -> 1初始: slow=1, fast=1
第1次: slow=2, fast=2
第2次: slow=2, fast=nil
结束: slow指向第二个2

3. 反转后半部分链表

go

var prev *ListNode
cur := slow
for cur != nil {next := cur.Nextcur.Next = prevprev = curcur = next
}

反转过程详解：

text

假设链表后半部分: 3 -> 2 -> 1 -> nil
cur = 3, prev = nil第1次循环:next = cur.Next = 2     // 保存下一个节点cur.Next = prev = nil   // 3 -> nilprev = cur = 3          // prev指向3cur = next = 2          // cur指向2第2次循环:next = cur.Next = 1     // 保存下一个节点cur.Next = prev = 3     // 2 -> 3prev = cur = 2          // prev指向2cur = next = 1          // cur指向1第3次循环:next = cur.Next = nil   // 保存下一个节点cur.Next = prev = 2     // 1 -> 2prev = cur = 1          // prev指向1cur = next = nil        // cur指向nil结果: 1 -> 2 -> 3 -> nil

4. 比较前后两部分

go

p1, p2 := head, prev
for p2 != nil {if p1.Val != p2.Val {return false}p1 = p1.Nextp2 = p2.Next
}

比较逻辑：

• p1 从头节点开始（前半部分）

• p2 从反转后的后半部分头节点开始

• 逐个比较节点的值，只要有一个不相等就返回 false

为什么只比较到 p2 != nil？

• 因为后半部分长度 ≤ 前半部分

• 奇数长度时，中间节点不需要比较

• 偶数长度时，两部分长度相等