leetcode25: Reverse Nodes in k-Group

Reverse Nodes in k-Group

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

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple ofk 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

 感受：此25题是24题的通用解法，当时在做24题时没有想到每遍历一个节点就将节点插入表头，当时只是想着把链表逆序,就这么一点点的差别在解题思路方面就会产生，很大的不同。至少所处的高度不同，那么相应的就感觉复杂很多。解题思路是将链表划分为每组长为k的n组子链表，然后在每组内，对链表进行遍历，每遍历到一个节点，则将次节点插入到子链表的头部。

程序分为两部分：

    1.  查找确定子链表

    2. 对子链表进行逆序

package leetcode;

public class leet25 {

private class ListNode{
int val;
ListNode next;
ListNode(){};
ListNode(int x){ val = x;}
}
public static void main(String[] args) {

leet25 leet = new leet25();

ListNode head = new leet25().new ListNode();
ListNode l1 = new leet25().new ListNode(1);
ListNode l2 = new leet25().new ListNode(2);
ListNode l3 = new leet25().new ListNode(3);
ListNode l4 = new leet25().new ListNode(4);
ListNode l5 = new leet25().new ListNode(5);
ListNode l6 = new leet25().new ListNode(6);

head.next = l1;
l1.next = l2;
l2.next = l3;
l3.next = l4;
l4.next = l5;
l5.next = l6;

ListNode result = leet.reverseKGroup(head,1);
while(result.next != null){
System.out.println(result.next.val);
result = result.next;
}
}
/**
*
* 解题思路是将链表划分为每组长为k的n组子链表，然后在每组内，对链表进行
* 遍历，每遍历到一个节点，则将次节点插入到子链表的头部
*
* 感受：此25题是24题的通用解法，当时在做24题时没有想到每遍历一个节点就将节点插入表头，当时只是想着把链表逆序
* 就这么一点点的差别在解题思路方面就会产生，很大的不同。至少所处的高度不同，那么相应的就感觉复杂很多
* @param head
* @param k
* @return
*/
public ListNode reverseKGroup(ListNode head,int k){

ListNode vHead = head;//上一个窗口的最后一个指针，可以理解为每一小组的头指针
ListNode end = vHead.next;//窗口的最后一个元素的下一个节点，即当前组，下一组的第一个节点
ListNode start = vHead.next;//每组未处理的第一个节点

while(true){
int i = 1;
while(i <= k){//查找每一组最后一个几点的下一个节点，即下一组的第一个节点
if(end == null){
return head;//程序终止返回的条件
}else{
end = end.next;
}
i++;
}
ListNode startBefore = vHead.next;//每一组处理过得第一个节点，即此节点的后继，始终是未处理的节点
ListNode startAfter = start.next;//当前待处理的节点的后一个节点

while(start != end){//对每组内的节点进行逆序处理
ListNode vHeadNext = vHead.next;
vHead.next = start;
start.next = vHeadNext;
startBefore.next = startAfter;

start = startAfter;//平移待处理节点指针
if(startAfter != null)//判断为空的目的是，当start指向链表的最后一个节点时，startAfter指向为空
startAfter = startAfter.next;
}
vHead = startBefore;//修改小组头指针
}
}
}