Leetcode: 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.

If the number of nodes is not a multiple of k 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

Analysis: Linked List节点倒序，Naive的方法就是用Stack，这样的话只需要K层Stack，不满足constant memory的条件；

第二遍方法（采用解法）两个指针：walker指向需改序序列的上一个节点，runner指向需改序序列最后节点，每次把walker下一个节点移到runner下一点处，直到walker.next = runner

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode walker = dummy;
        ListNode runner = dummy;
        while (runner.next != null) {
            int count = k;
            while (count > 0 && runner.next != null) {
                runner = runner.next;
                count--;
            }
            if (count == 0) walker = reverse(walker, runner);
            else break;
            runner = walker;
        }
        return dummy.next;
    }
    
    public ListNode reverse(ListNode walker, ListNode runner) {
        ListNode store = walker.next;
        while (walker.next != runner) {
            ListNode cur = walker.next;
            ListNode next = cur.next;
            cur.next = runner.next;
            runner.next = cur;
            walker.next = next;
        }
        return store;
    }
}

第二遍方法（另一种方法，可以但是不如第一种方法好写）：精髓在于reverse子函数，输入的两个参数分别是prev: 需改续序列的上一个节点，end: 需改续序列的下一个节点

reverse函数中设计比较精巧的地方在于，需要一开始保存一个start.next节点，最后作为start的新位置返回去更新start，这就是新的需改续序列的上一个节点位置（我一开始也就是卡在这里，不知如何更新start）

public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
 
        ListNode start = dummy;
        ListNode end = head;
        while (end != null) {
            int count = k;
            for (; count>0 && end!=null; count--) {
                end = end.next;
            }
            if (count == 0) {
                start = reverse(start, end);
            }
        }
        return dummy.next;
    }
    
    public ListNode reverse(ListNode start, ListNode end) {
        ListNode pre = end;
        ListNode store = start.next;
        ListNode cur = store;
        while (cur != end) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        start.next = pre;
        return store;
    }
}

Naive方法：使用Stack, 但不满足constant memeory的条件

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null) return null;
        ListNode prev = new ListNode(-1);
        prev.next = head;
        ListNode current = prev;
        while (head != null) {
            Stack<Integer> store = new Stack<Integer>();
            ListNode temp = head;
            int i = 0;
            for (; i < k; i++) {
                if (head == null) break;
                store.push(head.val);
                head = head.next;
            }
            if (i == k) {
                while (!store.empty()) {
                    current.next = new ListNode(store.pop());
                    current = current.next;
                }
            }
            else current.next = temp;
        }
        return prev.next;
    }
}

Gode Ganker的改指针做法(与我的第二遍方法2相仿)，输入给reverse函数的参数分别是：prev: 需改续序列的前一个节点，end: 需改续序列的后一个节点

基本思路是这样的，我们统计目前节点数量，如果到达k，就把当前k个结点reverse，这里需要reverse linked list的subroutine。这里我们需要先往前走，到达k的时候才做reverse，所以总体来说每个结点会被访问两次。总时间复杂度是O(2*n)=O(n)，空间复杂度是O(1)。

public ListNode reverseKGroup(ListNode head, int k) {
    if(head == null)
    {
        return null;
    }
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    int count = 0;
    ListNode pre = dummy;
    ListNode cur = head;
    while(cur != null)
    {
        count ++;
        ListNode next = cur.next;
        if(count == k)
        {
            pre = reverse(pre, next);
            count = 0;   
        }
        cur = next;
    }
    return dummy.next;
}
private ListNode reverse(ListNode pre, ListNode end)
{
    if(pre==null || pre.next==null)
        return pre;
    ListNode head = pre.next;
    ListNode cur = pre.next.next;
    while(cur!=end)
    {
        ListNode next = cur.next;
        cur.next = pre.next;
        pre.next = cur;
        cur = next;
    }
    head.next = end;
    return head;
}