Leetcode -- reverseKGroup

题目链接：https://oj.leetcode.com/problems/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

问题API：/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

public ListNode reverseKGroup(ListNode head, int k)

问题分析：其实这一题是reverse linked list的一个延伸版本，就是每k个元素分为一组，然后一组组的翻转。做法其实就是在reverse linklist的解答上准备好之前一组的最后一个指针和下一组的头指针，然后翻转组内元素，然后将前一组的最后一个元素连上翻转好的这一组，然后将翻转好的这一组的尾元素连上下一组的头元素，并且将这一组的尾元素维护好，留待下一次翻转时使用，需要注意的是当最后残余元素不足构成一组的时候，就不翻转。

给出代码如下：

    public void partialReverse(ListNode head, ListNode tail){
        ListNode prev = null, next = null, tmp = head, next_group = tail.next;
        while(tmp != next_group){
            next = tmp.next;
            tmp.next = prev;
            prev = tmp;
            tmp = next;
        }
    }
    
    public ListNode reverseKGroup(ListNode head, int k) {
        int m = k - 1;
        ListNode tmp = head, prev = null, new_head = null, next = null, part_head = head, part_tail = null;
        while(tmp != null){
            m--;
            tmp = tmp.next;
            if(m == 0 && tmp != null){
                next = tmp.next;
                part_tail = tmp;
                partialReverse(part_head, part_tail);
                if(new_head == null)
                    new_head = part_tail;
                if(prev != null)
                    prev.next = part_tail;
                prev = part_head;
                part_head.next = next;
                part_head = next;
                tmp = next;
                m = k - 1;
            }
        }        <pre name="code" class="java">        //这里判断的是一个特殊情况，当第一组的元素已经不足k个，那么就不会存在翻转的情况出现，直接返回头指针

  return new_head == null ? head : new_head; }

如果不熟悉翻转linkedlist的同学可以参考partialReverse的这个函数，这个就是翻转整个linkedlist的算法，每次翻转顺序都要除了两个参与反转的指针，还要保留参与反转的两个指针之前一个和之后的一个。这就是prev和next的作用。其实这一题就是reverselinklist的延伸运用，注意一下即可。