No.25 K个一组反转链表

25. K个一组反转链表

/**
 * 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 fir = new ListNode();
        fir.next = head;
        int i = 0 ;
        ListNode first = null;
        ListNode last = null;
        ListNode preNode = fir;
        while(head!=null) {
            if (i%k==0) {
                first = head;
                head = head.next;
            } else if ((i+1)%k==0) {
                last = head;
                ListNode[] array = reverse(first,last);
                preNode.next = array[0];
                //上一个子链表尾部的next = 下一个子链表的头节点
                array[1].next = array[2];
                preNode = array[1];
                head = array[2];
            } else {
                head = head.next;
            }
            i++;
        }
        return fir.next;
    }
   	/**
   	* 反转从node到tail的链表，并返回反转之后的首尾节点tail、node ，以及该链表的下一个节点newNode
   	**/
    public static ListNode[] reverse(ListNode node, ListNode tail) {
        ListNode head = node;
        ListNode nextNode = head.next;
        if (node==tail) {
            return new ListNode[]{head,head};
        }
        head.next = null; 
        //如果需要反转，需要同时知道一个节点的前后节点
        while (nextNode != tail) {
            ListNode third = nextNode.next;
            nextNode.next = head;
            head = nextNode;
            nextNode = third;
        }
        ListNode newNode = tail.next;
        node.next = newNode;
        tail.next  = head;
        //之前的tial变为了新的头节点，之前的头节点node变为了尾节点，为了确保不同子链表的顺序，需要知道
        //下一个子链表的头节点newNode
        return new ListNode[]{tail,node,newNode};
    }
}