LeetCode 25. Reverse Nodes in k-Group 以组的形式反转节点

25.以组的形式反转节点

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.

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 of k then left-out nodes in the end should remain as it is.

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

Note:

• Only constant extra memory is allowed.
• You may not alter the values in the list’s nodes, only nodes itself may be changed.

尾插法

每次先扫描k个节点，如果k个节点出现了null的节点，那么说明剩下的节点不足k个，所以不需要反转。直接保留。如果没有出现null节点，就对这k个节点进行反转。这里使用尾插法进行反转。尾插法即先固定头部，新添加的节点在后面添加。

以1->2->3->4 ，k为3的情况为例。它的变换过程如下。
3->1->2->4
3->2->1->4

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || k <= 1|| head.next == null){
            return head;
        }
        ListNode first = new ListNode(0);
        first.next = head;
        ListNode pre = first;
        ListNode cur = pre.next;
        ListNode post;
        ListNode end = first;
        while(true){
            int i = 0;
            while(i < k){
                end = end.next;
                if(end== null){
                    return first.next;
                }
                i++;
            }
            for(int j = 0; j < k -1; j++){
                post = cur.next;
                cur.next = post.next;
                post.next = pre.next;
                pre.next = post;
            }
            pre = cur;
            end = cur;
            cur = pre.next;
        }
    }
}

头插法

和上面的思想差不多，而这里使用的是头插法。头插法与尾插法相反，先固定尾部，然后新的节点在头部添加。

以1->2->3->4 ，k为3的情况为例。它的变换过程如下。

2->3->1->4

3->2->1->4

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        int i = 0;
        ListNode p = head;
        while(i < k && p!=null){
            p = p.next;
            i++;
        }
        if(i <k){
            return head;
        }
        
        ListNode pre = reverseKGroup(p,k);
        i = 0;
        p = head;
        while(i !=k){
            ListNode next = p.next;
            p.next = pre;
            pre = p;
            p = next;
            i++;
        }
        return pre;  
    }
 
}