LeetCode 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

具体思路请看代码。

Runtime: 8 ms ，别人最快的6ms。

	public ListNode reverseKGroup(ListNode head, int k) {
		int count = 0;
		ListNode cur = head,result;
		while (cur != null) {
			if (++count == k) {
				ListNode nextCur= cur.next;
				cur.next = null;
				result = reverseList(head);
				head.next = reverseKGroup(nextCur, k);
				return result;
			}
			cur = cur.next;
		}
		return head;
	}

	public ListNode reverseList(ListNode head) {
		if (head == null || head.next == null) return head;
		ListNode p = reverseList(head.next);
		head.next.next = head;
		head.next = null;
		return p;
	}

更简洁的写法：

	public ListNode reverseKGroup(ListNode head, int k) {
		if (head == null) return null;
		ListNode node = head;
		for (int i = 1; i <= k; i++) {
			if (node == null) return head;
			node = node.next;
		}
		ListNode cur = head, nextHead = reverseKGroup(node, k);
		while (cur != node) {
			ListNode tmp = cur.next;
			cur.next = nextHead;
			nextHead = cur;
			cur = tmp;
		}
		return nextHead;

	}

再来一种写法，和上面的效率是一样的

	public ListNode reverseKGroup3(ListNode head, int k) {
		ListNode[] stack = new ListNode[k];
		ListNode cur = head;
		int i = 0;
		while (i < k && cur != null) {
			stack[i++] = cur;
			cur = cur.next;
		}
		if (i < k) {
			return head;
		}
		head.next = reverseKGroup(cur, k);
		for (i = k - 1; i > 0; i--) {
			stack[i].next = stack[i - 1];
		}
		return stack[k - 1];

	}