Force buckle 25. Turn over the linked list in a group of K

Title source ：https://leetcode.cn/problems/reverse-nodes-in-k-group/

General meaning ：
Give a linked list and an integer k, Start the list from scratch every k Flip once , If the number of the last paragraph is insufficient k individual , There is no need to flip

Ideas

1. Design a function to flip the linked list , Given nodes node And length k, Can be node At the beginning k Nodes flipped . Attention should be paid to when designing , After flipping node.next You need to point to the last node of the linked list before flipping next
2. Use a variable to save the start node of the current linked list segment to be flipped , Traverse the original list , Every traversal k Time , Flip , Attention should be paid after turning , Of the previous node of the first node of the current linked list segment next Need to point to The first node after flipping

See code for details

public ListNode reverseKGroup(ListNode head, int k) {
    
        if (head == null || k == 1) {
    
            return head;
        }
        //  Number of nodes currently traversed 
        int count = 0;
        //  The start node of the currently flipped linked list segment 
        ListNode newHead = head;
        //  The node currently traversed 
        ListNode cur = head;
        //  sentry 
        ListNode ans = new ListNode(-1);
        //  The last section flips the tail node of the linked list 
        ListNode lastTail = ans;
        while (cur != null) {
    
            //  Update the number of nodes traversed 
            count++;
            //  If the number of traversal nodes is equal to  k, Flip 
            if (count == k) {
    
                //  First save the original header node of the current segment , That is, the inverted tail node 
                ListNode newTail = newHead;
                //  Reverse a linked list , At the same time, save the inverted head node of the next segment 
                newHead = reverse(newHead, k);
                //  Of the tail node of the previous paragraph  next  To point to the inverted head node 
                lastTail.next = newHead;
                //  Reset count 
                count = 0;
                //  Update the tail node of the previous paragraph 
                lastTail = newTail;
                //  Update the first node before turning the next segment 
                newHead = newTail.next;
                //  Update the current traversal location 
                cur = lastTail;
            }
            cur = cur.next;
        }
        return ans.next;
    }

    /** *  From the given  head  Node start  k  Nodes flipped  * @param head * @param k * @return */
    public ListNode reverse(ListNode head, int k) {
    
        //  The length of the current flip 
        int count = 1;
        //  Last convenient node 
        ListNode last = head;
        //  Currently traversing 
        ListNode cur = head.next;
        //  Temporary variable 
        ListNode temp;
        //  If the flipped length is not equal to  k  when , Continue flipping 
        while (count != k) {
    
            //  The length of the current flip  +1
            count++;
            //  Save the next node to traverse 
            temp = cur.next;
            //  Flip 
            //  Point the current linked list pointer to the previous node 
            cur.next = last;
            //  Update the last traversal node 
            last = cur;
            //  Update the next traversal node 
            cur = temp;
        }
        // newTail -> oldTail.next
        // head  It is the... After turning  k  Nodes , its  next  Point to the original  k  Of nodes  next, That is the first.  k + 1  Nodes 
        head.next = cur;
        //  Return to the first node after flipping 
        return last;
    }