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

Hide Tags

  Linked List

翻译：

Code：

package From21;

import From21.LeetCode24.ListNode;

/**
 * @author MohnSnow
 * @time 2015年6月10日 上午11:39:18
 * 
 */
public class LeetCode25 {

	/**
	 * @param argsmengdx
	 *            -fnst
	 */
	static class ListNode {
		int			val;
		ListNode	next;

		ListNode(int x) {
			val = x;
		}

		@Override
		public String toString() {
			if (this.next != null) {
				return val + "---" + this.next.toString();
			} else {
				return val + "";
			}
		}
	}

	//https://leetcode.com/discuss/31921/java-o-n-time-o-1-space-solution
	//352msA
	public static ListNode reverseKGroup(ListNode head, int k) {
		ListNode dummy = new ListNode(0);
		dummy.next = head;
		ListNode temp = dummy;
		ListNode current = head;
		ListNode reverse = null;
		ListNode reverseHead = temp;
		ListNode reverseTail = temp.next;
		while (current != null) {
			reverseHead = temp;
			reverseTail = temp.next;
			temp = temp.next;
			for (int i = 0; i < k; i++) {
				if (current == null)
					return dummy.next;
				current = current.next;
			}
			current = temp;
			for (int i = 0; i < k; i++) {
				current = current.next;
				temp.next = reverse;
				reverse = temp;
				temp = current;
			}
			reverseHead.next = reverse;
			reverseTail.next = current;
			reverse = null;
			temp = reverseTail;
		}
		return dummy.next;
	}

	//自己写的指针好乱好多好杂啊
	public static ListNode reverseKGroup1(ListNode head, int k) {
		ListNode dummy = new ListNode(0);
		dummy.next = head;
		ListNode temp = dummy;
		ListNode current = head;
		ListNode T2 = null;
		ListNode reverse = null;
		ListNode T1 = dummy;
		while (current != null) {
			head = current;
			for (int i = 0; i < k - 1; i++) {
				if (current == null) {
					return dummy.next;
				}
				current = current.next;
			}
			reverse = current;
			T1.next = reverse;
			reverse.next = null;
			T1 = head;
			current = current.next;
			head.next = current;
			temp = head;
			for (int j = 1; j < k; j++) {
				temp = head.next;
				if (temp.next == null) {
					temp.next = head;
					break;
				} else {
					T2 = temp.next;					
				}
				temp.next = head;
				head = temp;
				temp = T2;
			}
		}
		return dummy.next;
	}

	//340msA
	public static ListNode reverseKGroup2(ListNode head, int k) {
		if (head == null) {
			return head;
		}
		ListNode tail = head;
		for (int i = 1; i < k; i++) {
			tail = tail.next;
			if (tail == null) {
				return head;
			}
		}
		ListNode nextRoundHead = tail.next;//下一轮的第一个数
		ListNode second = head.next;
		ListNode first = head;
		for (int i = 1; i < k; i++) {//reserve the k node group
			ListNode newSecond = second.next;
			second.next = first;
			first = second;
			second = newSecond;
		}
		head.next = reverseKGroup(nextRoundHead, k);
		return tail;
	}

	public static void main(String[] args) {
		ListNode a = new ListNode(1);
		ListNode b = new ListNode(2);
		ListNode c = new ListNode(3);
		ListNode d = new ListNode(4);
		ListNode e = new ListNode(5);
		ListNode f = new ListNode(6);
		ListNode g = new ListNode(7);
		ListNode h = new ListNode(8);
		a.next = b;
		b.next = c;
		c.next = d;
		d.next = e;
		e.next = f;
		f.next = g;
		g.next = h;
		h.next = null;
		int k = 5;
		//System.out.println("第一种：" + reverseKGroup(a, k));
		System.out.println("第二种：" + reverseKGroup1(a, k));
		//System.out.println("第三种：" + reverseKGroup2(a, k));
	}

}