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;  
    }
 
}