给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

解题思路：

这道题其实记住一点就可以了，每K个节点进行一下反转，反转之后记得拼接成一条新链表，下次反转针对于新的链表进行更改。

代码实现：

public class Solution_113 {

    private static class Node {
        int value;
        Node next;

        public Node(int value) {
            this.value = value;
        }
    }

    public Node reverseKGroup(Node head, int k) {
        if (head == null || head.next == null || k <= 0) return head;

        Node hNode = head;
        Node preNode = null;
        Node startNode = head;

        int index = 0;
        while (head != null) {
            head = head.next;
            index++;

            if (index % k == 0) {
                Node[] nodes = reverse(startNode, head, preNode, head);
                preNode = nodes[1];
                startNode = head;

                if (index / k == 1) {
                    hNode = nodes[0];
                }
            }
        }

        return hNode;
    }

    private Node[] reverse(Node start, Node end, Node head, Node tail) {
        Node lastNode = start;

        Node preNode = null;
        while (start != end) {
            Node temp = start.next;
            start.next = preNode;
            preNode = start;
            start = temp;
        }

        lastNode.next = tail;
        if (head != null) {
            head.next = preNode;
        }

        return new Node[]{preNode, lastNode};
    }

    public static void main(String[] args) {
        Solution_113 solution_113 = new Solution_113();

        Node head = new Node(1);
        Node next = new Node(2);
        Node next1 = new Node(3);
        Node next2 = new Node(4);
        Node next3 = new Node(5);
        head.next = next;
        next.next = next1;
        next1.next = next2;
        next2.next = next3;

        Node res = solution_113.reverseKGroup(head, 2);

        print(res);
    }

    private static void print(Node node) {
        while (node != null) {
            System.out.println(node.value);
            node = node.next;
        }
    }
}