个人记录-LeetCode 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.

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

问题要求：给定一个链表，以及指定的逆序长度k。
链表中每连续k个节点，都需要进行逆序；
若连续节点的长度小于k个，则不做逆序操作。
这里要求使用内存必须是常量级别。

思路：

对于连续的K个节点，我们定义prev、begin、end和nextBegin这几个指针。
如图所示，含义还是很清晰的，不作赘述。

在开始时，将prev的next变为end。
然后，定义一个move指针，从begin开始移动到end的前一个节点。
于是end的next指向move。

end前移到move的位置。
move又从begin开始，移动到end的前一个节点。
再次进行与上面一样的修改。

直到，end移动到begin的后面。
此时，将end的next修改为begin。
begin的next修改为nextBegin，begin将作为后续连续K个节点的Prev。

以上方法并不是最快的，但占用的内存是常数级的(只用到了引用)，满足要求。
当然，实际上我这里从最后开始逆着修改next，比较耗时。

从前往后修改也是可以的，只用一个引用保存下一个要修改的节点即可。

代码示例：
1、逆着修改next

/**
 * 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 temp = head;
        int len = 0;
        //先判断长度够不够
        while (temp != null) {
            ++len;
            if (len == k) {
                break;
            }
            temp = temp.next;
        }

        if (len != k) {
            return head;
        }

        //初始时prev为null
        ListNode prev = null;
        ListNode begin = head;

        //长度够的话，最终的头为此时的第K个节点
        head = temp;

        while (begin != null) {
            //每次操作前，记录当前的begin，这是下一次的prev
            ListNode lastBegin = begin;
            begin = reverseKGroupInternal(prev, begin, k);
            prev = lastBegin;
        }

        return head;
    }

    private ListNode reverseKGroupInternal(ListNode prev, ListNode begin, int k) {
        ListNode temp = begin;
        ListNode end = null;
        ListNode nextBegin = null;

        int len = 0;
        //同样需要判断此次操作的长度是否满足条件
        while (temp != null) {
            ++len;
            if (len == k) {
                //得到本次操作的end及nextBegin
                end = temp;
                nextBegin = end.next;
                break;
            }
            temp = temp.next;
        }

        if (len != k || end == null) {
            return null;
        }

        //prev的next指向end
        if (prev != null) {
            prev.next = end;
        }

        ListNode move;
        while (begin.next != end) {
            //移动move到end的前面
            move = begin;
            while (move.next != end) {
                move = move.next;
            }
            //end的next指向move
            end.next = move;
            //前移end
            end = move;
        }
        //最后时刻，end刚好在begin后面
        //修改end.next指向begin
        end.next = begin;
        //begin.next指向nextBegin
        begin.next = nextBegin;

        return nextBegin;
    }
}

2、基本逻辑与上面一致，就是顺着改next

/** * 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 temp = head;
        int len = 0;
        while (temp != null) {
            ++len;
            if (len == k) {
                break;
            }
            temp = temp.next;
        }

        if (len != k) {
            return head;
        }

        ListNode prev = null;
        ListNode begin = head;

        head = temp;

        while (begin != null) {
            ListNode lastBegin = begin;
            begin = reverseKGroupInternal(prev, begin, k);
            prev = lastBegin;
        }

        return head;
    }

    private ListNode reverseKGroupInternal(ListNode prev, ListNode begin, int k) {
        ListNode temp = begin;
        ListNode end = null;
        ListNode nextBegin = null;
        int len = 0;
        while (temp != null) {
            ++len;
            if (len == k) {
                end = temp;
                nextBegin = end.next;
                break;
            }
            temp = temp.next;
        }

        if (len != k || end == null) {
            return null;
        }

        if (prev != null) {
            prev.next = end;
        }

        ListNode first = begin;
        ListNode second = begin.next;

        begin.next = nextBegin;

        //只有下面这部分存在差异
        while(second != null && second != end) {
            ListNode local = second.next;
            second.next = first;
            first = second;
            second = local;
        }

        if (second != null) {
            second.next = first;
        }

        return nextBegin;
    }
}