K 个一组翻转链表

题目描述：

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
示例 3：

输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：

输入：head = [1], k = 1
输出：[1]
提示：

列表中节点的数量在范围 sz 内
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz

思路:

先遍历k遍判断有没有到终点，遍历之后找到一段的tail和head，然后进入reverse函数，倒转head和tail，表的head和tail连接主表的pre和nex

pre.Next=head
tail.Next=nex

代码:

func reverseKGroup(head *ListNode, k int) *ListNode {
    hair := &ListNode{Next: head}
    pre:=hair
    if k==1{
        return head
    }else{
        for head!=nil{
            tail:=pre
            //判断结点数量大不大于k个
            for i:=0;i<k;i++{
                tail=tail.Next
                if tail==nil{
                    return hair.Next
                }
            }
            nex:=tail.Next
            head,tail=reverse(head,tail)
            pre.Next=head
            tail.Next=nex
            pre=tail
            head=tail.Next
            
        }
    }
    return hair.Next
}
func reverse(head,tail *ListNode)(*ListNode,*ListNode){
    var head2 *ListNode=nil
    p:=head
    tail.Next=nil
    for p!=nil{
        tmp:=p.Next
        p.Next=head2
        head2=p
        p=tmp
    }
    return head2,head
}

代码效率：

执行用时：4 ms, 在所有 Go 提交中击败了90.13%的用户
内存消耗：3.6 MB, 在所有 Go 提交中击败了50.96%的用户