链表中的节点每k个一组翻转

思路
将链表中前k个节点存入栈，再取出恰好可以实现每k个一组翻转，要注意临界条件：链表的最后一个节点放入之后，栈的大小小于k值。
代码

/**
 *
 * @param head ListNode类
 * @param k int整型
 * @return ListNode类
 */
public ListNode reverseKGroup (ListNode head, int k) {
    // write code here
    ListNode result;                
    ListNode key = new ListNode(0);     //初始化重构后的链表
    result=key;

    if(head==null||k<=0){               
        return null;
    }
    if (head.next==null){
        return head;
    }
    else {
        Stack<ListNode> stack = new Stack<ListNode>();   //创建栈存入前k个节点
        while (head!=null){
            for (int i=0;i<k;i++){
                stack.push(head);
                head=head.next;

                //当栈已经存满前k个节点
                if (stack.size()==k){
                    while (!stack.isEmpty()){          
                        ListNode node= new ListNode(stack.pop().val);
                        key.next=node;
                        key=key.next;
                    }
                }

                //当最后一个节点存入栈的大小仍然小于k
                if (head==null&&stack.size()!=k){
                    Stack<ListNode> queue = new Stack<>();
                    while (!stack.isEmpty()){
                        queue.add(stack.pop());
                    }
                    while (!queue.isEmpty()){
                        ListNode node= new ListNode(queue.pop().val);
                        key.next=node;
                        key=key.next;
                    }
                }
                break;     //跳出循环
            }
        }
    }
    return result.next;
}