从头开始，每K个一组，翻转链表

js
package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

// ================= 核心函数 =================

// 每 K 个一组翻转（从头开始）
func reverseKGroup(head *ListNode, k int) *ListNode {
	if head == nil || k <= 1 {
		return head
	}

	dummy := &ListNode{Next: head}
	pre := dummy

	for {
		// 1. 找到这一组的 tail
		tail := pre
		for i := 0; i < k; i++ {
			tail = tail.Next
			if tail == nil {
				return dummy.Next // 不够K个
			}
		}

		// 2. 记录下一组起点
		next := tail.Next

		// 3. 翻转这一组
		start := pre.Next
		newHead, newTail := reverse(start, tail)

		// 4. 接回链表
		pre.Next = newHead
		newTail.Next = next

		// 5. pre 移动到下一组
		pre = newTail
	}
}

// 翻转 [head, tail] 区间
func reverse(head, tail *ListNode) (*ListNode, *ListNode) {
	prev := tail.Next
	cur := head

	for prev != tail {
		next := cur.Next
		cur.Next = prev
		prev = cur
		cur = next
	}

	return tail, head
}

// ================= 辅助函数 =================

// 构建链表
func buildList(nums []int) *ListNode {
	dummy := &ListNode{}
	cur := dummy

	for _, v := range nums {
		cur.Next = &ListNode{Val: v}
		cur = cur.Next
	}

	return dummy.Next
}

// 打印链表
func printList(head *ListNode) {
	cur := head
	for cur != nil {
		fmt.Printf("%d -> ", cur.Val)
		cur = cur.Next
	}
	fmt.Println("null")
}

// ================= 测试 =================

func main() {
	head := buildList([]int{1, 2, 3, 4, 5, 6})

	k := 3

	fmt.Println("原链表：")
	printList(head)

	newHead := reverseKGroup(head, k)

	fmt.Println("每K个翻转后：")
	printList(newHead)
}