public class Main {
	public static void main(String[] args) {
		ListNode head = new ListNode(3);
		ListNode node1 = new ListNode(5);
		ListNode node2 = new ListNode(6);
		ListNode node3 = new ListNode(9);
		ListNode node4 = new ListNode(7);
		ListNode node5 = new ListNode(2);
		ListNode node6 = new ListNode(1);
		ListNode node7 = new ListNode(12);
		head.next = node1;
		node1.next = node2;
		node2.next = node3;
		node3.next = node4;
		node4.next = node5;
		node5.next = node6;
		node6.next = node7;
		printList(head);
//		printList(reverseNode(head));
//		printList(reverseKgroups(head, 3));
		printList(reverseKgroup(head, 3));

	}

	// 列印連結串列的方法，方便test函式
	public static void printList(ListNode head) {
		while (head != null) {
			System.out.print(head.val + " ");
			head = head.next;
		}
		System.out.println();
	}
	/**
	 * 分組反轉單鏈表，最後不足K個節點的部分不反轉
	 * @param head
	 * @param k
	 * @return
	 */
	public static ListNode reverseKgroups(ListNode head, int k) {
		if (head == null)
			return head;
		ListNode cur = head;
		ListNode reHead = null;

		int count = 0;
		if (getSize(cur) >= k) {
			/* Reverse first k nodes of linked list */
			while (count < k && cur != null) {
				ListNode reCur = cur;
				cur = cur.next;
				reCur.next = reHead;
				reHead = reCur;
				count++;
			}
			/*
			 * cur is now a pointer to (k+1)th node Recursively call for the
			 * list starting from current. And make rest of the list as next of
			 * first node
			 */
			if (cur != null)
				head.next = reverseKgroups(cur, k);
			return reHead;
		}
		return cur;
	}

	/**
	 * 分組反轉單鏈表，最後不足K個節點的部分也反轉
	 * @param head
	 * @param k
	 * @return
	 */
	public static ListNode reverseKgroup(ListNode head, int k) {
		if (head == null)
			return head;
		ListNode cur = head;
		ListNode reHead = null;

		int count = 0;
		/* Reverse first k nodes of linked list */
		while (count < k && cur != null) {
			ListNode reCur = cur;
			cur = cur.next;
			reCur.next = reHead;
			reHead = reCur;
			count++;
		}
		/*
		 * cur is now a pointer to (k+1)th node Recursively call for the
		 * list starting from current. And make rest of the list as next of
		 * first node
		 */
		if (cur != null)
			head.next = reverseKgroup(cur, k);
		
		return reHead;
	}
	/**
	 * 統計該節點之後的節點數量
	 * @param head
	 * @return
	 */
	public static int getSize(ListNode head) {
		int count = 0;
		ListNode curNode = head;
		while (curNode != null) {
			count++;
			curNode = curNode.next;
		}
		return count;
	}
	


	/*
	 * 翻轉連結串列（遍歷） 從頭到尾遍歷原連結串列，每遍歷一個結點， 將其摘下放在新連結串列的最前端。 注意連結串列為空和只有一個結點的情況。時間複雜度為O（n）
	 */
	public static ListNode reverseNode(ListNode head) {
		// 如果連結串列為空或只有一個節點，無需反轉，直接返回原連結串列表頭
		if (head == null || head.next == null)
			return head;

		ListNode reHead = null;
		ListNode cur = head;
		while (cur != null) {
			ListNode reCur = cur; // 用reCur儲存住對要處理節點的引用
			cur = cur.next; // cur更新到下一個節點
			reCur.next = reHead; // 更新要處理節點的next引用
			reHead = reCur; // reHead指向要處理節點的前一個節點
		}
		return reHead;
	}

}
class ListNode {
      int val;
      ListNode next;
      ListNode(int x) { val = x; }
}