Every k nodes in the linked list are flipped

problem

Every node in the given linked list k Turn over in groups , Returns the flipped linked list
If the number of nodes in the linked list is not k Multiple , Leave the last remaining nodes as they are
You cannot change the value in a node , Only the node itself can be changed .

Ideas

The double pointer determines the inversion interval , Then reverse the list , Return to the new header node , After the original head node is reversed, it becomes the tail node . Every recursive call , take k Nodes reversed , And return the inverted new head node .

Code implementation

/** * struct ListNode { * int val; * struct ListNode *next; * }; */

class Solution {
    
public:
    /** * * @param head ListNode class  * @param k int integer  * @return ListNode class  */
    ListNode* reverseKGroup(ListNode* head, int k) {
    
        // write code here
        ListNode* tail = head;
        //  Walk forward  k  Step , Determine the inversion interval 
        for (int i = 0; i  < k; i++)
        {
    
            if (!tail) return head;
            tail = tail->next;
        }
        //  Interval reversal , Return to the new header node 
        ListNode* newHead = reverse(head, tail);
        //  After reversing  head  become   Tail node 
        head->next = reverseKGroup(tail, k);
        return newHead;
        
    }
    ListNode* reverse(ListNode* head, ListNode* tail)
    {
    
        ListNode* pre = NULL;
        ListNode* cur = head;
        //  List reversal , return  tail  Previous node 
        while (cur != tail)
        {
    
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};