Solution Class Reference

Public Member Functions
ListNode *	reverseKGroup (ListNode *head, int k)

Detailed Description

Definition at line 17 of file main.cpp.

Member Function Documentation

reverseKGroup()

ListNode * Solution::reverseKGroup ( ListNode *  head, int  k  )

inline

Definition at line 20 of file main.cpp.

    {
        if (!head || k == 1) return head;
        
        // new list to reconstruct the reversed k-groups
        list<ListNode*> new_list;
        
        // k-sized stack for reversing groups
        stack<ListNode*> s;
        
        ListNode* ptr = head;
        bool stop = false;
        while (1)
        {
            // skipping k times to establish if full k-sized group is present
            ListNode* fast = ptr;
            for (int i = 0; i < k; ++i)
            {
                if (fast == nullptr)
                {
                    stop = true;
                    break;
                }
                fast = fast->next;
            }
            if (stop)
                break;
 
            // pushing k-sized group to stack
            for (int i = 0; i < k; ++i)
            {
                s.push(ptr);
                ptr = ptr->next;
            }
 
            // emptying stack into new list
            while (!s.empty())
            {
                new_list.push_back(s.top());
                s.pop();
            }
        }
 
        // append the rest normally
        while (ptr != nullptr)
        {
            new_list.push_back(ptr);
            ptr = ptr->next;
        }
 
        // reconstruct the list from head
        head = new_list.front();
        new_list.pop_front();
        ptr = head;
        for (ListNode* node: new_list)
        {
            ptr->next = node;
            ptr = ptr->next;
        }
        ptr->next = nullptr;
        return head;
    }

References ListNode::next.

Referenced by main().

---

The documentation for this class was generated from the following file:

• main.cpp