链表中的节点每k个一组翻转

 

 

/**
 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 * };
 */
 
class Solution {
public:
    /**
     *
     * @param head ListNode类
     * @param k int整型
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k)
    {
        if(head == nullptr) //判空操作
        {
            return head;
        }

        ListNode * dummy = new ListNode(0);  //创建一个节点连接head
        dummy->next = head;

        ListNode * phead_con = dummy;   //此指针连接反转后链表的第一个节点
        ListNode * ptail_con = dummy;   //反转后链表的最后一个节点连接此指针指向的节点
         
        ListNode * start =  head;       //用于一段链表反转的指针  开始反转的位置
        ListNode * end   = head;        //结束反转的位置
         
        int count = 1;
         
        while(end) //如果 end 不为 nullptr 那么将会一直进行反转的操作
        {
            if(count >= k)  //当计数大于等于k时，也就是说end指针已经指过了k个节点，需要进行反转了
            {
                count = 1;
                ptail_con = end->next; //ptail_con 先指向后面没有被反转的节点
                 
                ListNode * pre = nullptr;   //下面时对一段链表进行反转
                ListNode * cur = start;     //start就是指向反转链表开始的节点
                ListNode * nxt = nullptr;
                while(cur != ptail_con)     //当cur指向不需要反转的节点ptail_con时就停止反转
                {
                    nxt = cur->next;
                    cur->next = pre;
                    pre = cur;
                    cur = nxt;
                }
            
                //反转后链表需要再接入到原来的链表中 
                //需要注意的是，一段反转完后，start指向的节点是尾，end指向的节点是头
                phead_con->next = end;      
                start->next = ptail_con;

                //此时是重新整理状态，
                phead_con = start;     
                ptail_con = start;

                //控制反转的start 和 end 都指向下一组要反转的链表的第一个节点
                start = start->next;
                end = start;
                continue;
            }
            count++;
            end = end->next;  //end指针指向下一个
        }
        return dummy->next;
    }
};