Leetcode25--->Reverse Nodes in k-Group(以k个节点为段，反转单链表)

题目： 给定一个单链表，一次反转k个节点，最终返回翻转后的链表的头节点；如果链表不足k个，则不变

举例：

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.  首先要确定链表的头节点newHead;即如果链表的节点个数大于k,则头节点为第k个节点；否则头节点不变；

2.  区分每一段，即确定段的开始和结尾；当前段的开始start, 段的结尾可以用k确定；下一段的开始为end;

3.  每k个节点之间的反转；

4.  段与段之间的连接，prevNode指向前一段的最后一个节点；

 /**
  * Definition for singly-linked list.
  * public class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public ListNode reverseKGroup(ListNode head, int k) {
         if(head == null || k <= 1)
             return head;
         ListNode begin = head; // begin是当前段的开始
         ListNode end = begin;  // end是下一段的开始
         ListNode newHead = begin;  // 新的链表头
         ListNode prevNode = head;  // 是上一段的最后一个节点
         int flag = 0;  // 记录是第几段
         while(end != null){
             int count = 1;
             while(end.next != null && count < k){
                 end = end.next;
                 count ++;
             }
             if(count == k){
                 if(flag == 0){
                     newHead = end;
                 }
                 flag ++;
                 if(flag > 1){  // 不是第一段时就需要段与段之间的连接
                     prevNode.next = end;  // 段和段之间进行连接
                     prevNode = begin;
                 }
                 end = end.next;  // 下一个段的开始
                 ListNode prev = null;
                 int i = 0;
                 while(i < k){  // 链表的反转
                     ListNode nextNode = begin.next;
                     begin.next = prev;
                     prev = begin;
                     begin = nextNode;
                     i++;
                 }
                 begin = end;   // 下一个段的开始
                 prevNode.next = end;  // 两个段之间连接，是为了避免下一段节点数不足k个，则不能使用第30行代码来连接段
             }
             else
                 break;
         }
         return newHead;
     }
 }