25. K 个一组翻转链表

方法：模拟

使用翻转单链表的方法，加上递归处理

时间复杂度：O(n)，其中 n 为链表的长度。
空间复杂度：O(1)，我们只需要建立常数个变量

type ListNode struct{
	Val int
	Next *ListNode
}
func main(){
	// 构造链表 A
	nodeA1 := &ListNode{Val: 1}
	nodeA2 := &ListNode{Val: 2}
	nodeA3 := &ListNode{Val: 3}
	nodeA4 := &ListNode{Val: 4}
	nodeA5 := &ListNode{Val: 5}
	nodeA1.Next = nodeA2
	nodeA2.Next = nodeA3
	nodeA3.Next = nodeA4
	nodeA4.Next = nodeA5

	ansHead:=reverseKGroup(nodeA1,2)
	//头节点开始输出
	for ansHead!=nil{
		fmt.Println(ansNode.Val)
		ansHead=ansNode.Next
	}


}
func reverseKGroup(head *ListNode, k int) *ListNode {
	var pre, next *ListNode
	var cur, p *ListNode = head, head
	groupSize, index := 0, 0

	// 确定当前分组的大小
	for p != nil && groupSize < k {
		p = p.Next
		groupSize++
	}
	if groupSize == k {
		// 反转当前分组的节点
		for cur != nil && index < k {
			next = cur.Next
			cur.Next = pre
			pre = cur
			cur = next
			index++
		}

		if next != nil {
			// 递归反转下一个分组，并将当前分组的尾部连接到下一个分组的头部
			head.Next = reverseKGroup(next, k)
		}
		return pre // 返回当前分组反转后的头部
	} else {
		return head // 当分组大小不足 k 时，保持不变，返回原始头部
	}
}