25. Reverse Nodes in k-Group

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

思路：

1.k小于或等于链表的长度，依次遍历链表，将节点入栈，当栈中元素个数等于k时，开始将栈中的元素建立翻转链表。如此循环。最后，当不满k个时，只需要找到栈底的元素，并将其与先前的链表连接起来，构成新链表。

2.当k 大于链表的长度，直接返回原链表的头结点。

问题：这种做法算不算只是用了固定的内存空间？

//	这个是使用栈进行翻转的
	public ListNode reverseKGroup(ListNode head, int k) {
		if(head == null || k>getLength(head)) return head;
        Stack<ListNode> stack1 = new Stack<>();
        ListNode curr = head;
        ListNode head1 = null;
        ListNode pre = null;
        while(curr!=null){
        	stack1.push(curr);
        	if(stack1.size()==k){
        		ListNode post = curr.next;
        		while(!stack1.isEmpty()){
        			ListNode p = stack1.pop();
        			p.next = null;
        			if(head1 == null){
        				head1 = p;
        				pre = p;
        			}else{
        				pre.next = p;
        				pre = pre.next;
        			}
        		}
        		curr = post;
        	}else{
        		curr = curr.next;
        	}
        }
        if(stack1.size()>0 && stack1.size()<k ){
        	ListNode p = null;
        	//找到栈底元素，和原链表连接起来
        	while(!stack1.isEmpty()){
    			p = stack1.pop();
            }
        	pre.next = p;
        }
        return head1;
    }
	
	public int getLength(ListNode head){
		ListNode p = head;
		int length = 0;
		while(p!=null){
			length++;
			p = p.next;
		}
		return length;
	}