25. K 个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

 因为链表翻转可以通过递归或者迭代进行，所以可以先建立一个方法，方法输入为头节点与k值，返回值为翻转以后的头节点与子链表的尾节点。然后使用上一个翻转链表的尾节点连接此链表的头节点。所以在这里要定义一个指针节点pre，每次翻转过后pre=尾节点。由于第一个翻转链表没有pre所以需先定义一个hair节点，hair节点的next指向head节点，然后让此pre指向hair。

如果最后一个子链表长度小于k，则不需调用方法翻转链表，直接返回整个链表。即return hair.next。

for(int i = 0;i < k;i++){              
                tail = tail.next;
                if(tail == null){
                    return hair.next;
                }
            }

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode hair = new ListNode(0);
        hair.next = head;
        ListNode pre = hair;
        while(head != null){
            //判断剩余节点是否为空
            ListNode tail = pre;
            for(int i = 0;i < k;i++){              
                tail = tail.next;
                if(tail == null){
                    return hair.next;
                }
            }
            ListNode nex = tail.next;
            ListNode[] reverse = reverseList(head,tail);
            head = reverse[0];
            tail = reverse[1];
            //把子链表接入原链表
            pre.next = head;
            tail.next = nex;
            pre = tail;
            head = tail.next;
        }
        
        return hair.next;

    }
    public ListNode[] reverseList(ListNode head,ListNode tail){
        ListNode prev = tail.next;
        ListNode p = head;
        while (prev != tail) {
            ListNode nex = p.next;
            p.next = prev;
            prev = p;
            p = nex;
        }
        return new ListNode[]{tail, head};
    }
}