【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

---

题解：思路很简单，一步步做就可以了。除了题目要求实现的函数，另外实现了两个函数：

 private ListNode[] reverseSub(ListNode head,int k) 该函数将head所指向的长度为k的链表反转，返回一个大小为2的数组，数组中第一个元素是反转后的链表的头节点，第二个元素是反转后的链表的尾节点。

 private int getlength(ListNode head) 该函数返回head所指向的链表的长度。

在reverseKGroup函数中，首先计算原链表的长度len，那么需要反转的组的数目就是len/k，接下来调用reverseSub函数len/k次，反转每一段链表，然后根据返回的首尾指针把它们串起来。最后根据len%k是否为0判断链表中是否有不需要反转的元素，如果有，把它们链在链表最后面返回。

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    private ListNode[] reverseSub(ListNode head,int k){
        ListNode[] answer = new ListNode[2];
        answer[1] = head;
        ListNode prev = null;
        for(int i = 0;i < k;i++){
            ListNode temp = head.next;
            head.next = prev;
            prev = head;
            head = temp;
        }
        answer[0] = prev;
        return answer;
    }
    private int getlength(ListNode head){
        int count = 0;
        while(head != null){
            count ++;
            head = head.next;
        }
        return count;
    }

    public ListNode reverseKGroup(ListNode head, int k) {
        int len = getlength(head);
        if(len < k)
            return head;
        
        ListNode answer = null;
        ListNode tail = new ListNode(0);
        int for_num = len / k;
        for(int i = 0;i < for_num;i++){
            ListNode h = head;
            
            //find next starter
            for(int j = 0;j < k;j++)
                head = head.next;
            
            ListNode[] temp = reverseSub(h, k);
            if(answer == null){
                answer = temp[0];
                tail = temp[1];
            }
            else {
                tail.next = temp[0];
                tail = temp[1];
            }                        
        }
        
        if(len%k != 0)
            tail.next = head;
        else
            tail.next = null;
        
        return answer;
    }
}