[LeetCode]Reverse Nodes in k-Group, 解题报告

今天收到了阿里的电子入职offer，看岗位的要求是要熟悉linux内核，迅速入手了一本《Linux内核设计与实现》，入职前希望能翻完一遍，在亚马逊货到付款下周二才能送到，这两天还是按部就班的写写LeetCode代码

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

题目比较容易理解，因为涉及到的指针操作较多，所以这里也记录一下。解题方法：

1. 处理特殊的情况，例如指针为空，翻转数k为1
2. 获取需要翻转的次数，次数 = 节点总数 / k
3. 将翻转k个节点抽象成局部函数，供主函数调用即可

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public static ListNode reverseKGroup(ListNode head, int k) {
        int count = 0;
        ListNode p = head;
        while (p != null) {
            count ++;
            p = p.next;
        }
        
        // special case
        if (count < k || k == 1) {
            return head;
        }
        
        // loop count
        int loopCount = count / k;
        
        // local variable
        ListNode safeNode = new ListNode(Integer.MAX_VALUE);
        safeNode.next = head;
        
        ListNode pre = safeNode;
        ListNode cur = head;
        
        for (int i = 0; i < loopCount; i ++) {
            ListNode tmp = reverseK(cur, k);
            pre.next = tmp;
            
            ListNode tmpPre = null;
            ListNode tmpCur = tmp;
            
            for (int j = 0; j < k; j ++) {
                tmpPre = tmpCur;
                tmpCur = tmpCur.next;
            }
            
            pre = tmpPre;
            cur = tmpCur;
        }
        
        return safeNode.next;
    }
    
    public static ListNode reverseK(ListNode head, int k) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode post = null;
        
        for (; k > 0 && cur != null; k --) {
            post = cur.next;
            
            cur.next = pre;
            pre = cur;
            cur = post;            
        }     
        head.next = cur;
        
        return pre;
    }
}