题解 | # 链表中的节点每k个一组翻转 #

本题关键在于理清思路，避免冗长的边界判断，具体地，为了解耦，专门开个函数用于反转指定区间内的链表节点，并且返回反转之后的头尾节点。在主函数中，只需要k个一组分割节点，调用函数即可，同时使用经典的虚拟头节点辅助。

import . "nc_tools"
/*
 * type ListNode struct{
 *   Val int
 *   Next *ListNode
 * }
 */

/**
  * 
  * @param head ListNode类 
  * @param k int整型 
  * @return ListNode类
*/
func reverseKGroup( head *ListNode ,  k int ) *ListNode {
    // write code here
    dummyHead := &ListNode{}
    pretail := dummyHead
    cur := head
    for  {
        tmphead := cur
        for i := 1;i < k && cur != nil;i++ {
            cur = cur.Next
        }
        if cur == nil {
            pretail.Next = tmphead
            break
        }
        tmptail := cur
        nexthead := tmptail.Next
        reversehead,reversetail := reverseList(tmphead,tmptail)
        pretail.Next = reversehead
        pretail = reversetail
        cur = nexthead
    }
    return dummyHead.Next
}

func reverseList(head *ListNode,tail *ListNode) (newhead *ListNode,newtail *ListNode){

    var pre *ListNode
    cur := head
    for cur != tail {
        tmp := cur.Next
        cur.Next = pre
        pre = cur
        cur = tmp
    }
    cur.Next = pre
    newhead = tail
    newtail = head
    return
}