Reverse a doubly linked list in groups of given size | Set 2

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// A linked list node
class Node {
public:
    int data;
    Node* next;
    Node* prev;
};

// Given a reference (pointer to pointer)
// to the head of a list
// and an int, inserts a new node on the
// front of the list.
void push(Node** head_ref, int new_data)
{

    // Allocate node
    Node* new_node = new Node();

    // Put in the data
    new_node->data = new_data;

    // Make next of new node as head
    // and previous as NULL
    new_node->next = (*head_ref);
    new_node->prev = NULL;

    // Change prev of head node to new node
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;

    // Move the head to point to the new node
    (*head_ref) = new_node;
}

// Given a node as prev_node, insert
// a new node after the given node
void insertAfter(Node* prev_node, int new_data)
{

    // Check if the given prev_node is NULL
    if (prev_node == NULL) {
        cout << "the given previous "
             << "node cannot be NULL";
        return;
    }

    // Allocate new node
    Node* new_node = new Node();

    // Put in the data
    new_node->data = new_data;

    // Make next of new node as next of prev_node
    new_node->next = prev_node->next;

    // Make the next of prev_node as new_node
    prev_node->next = new_node;

    // Make prev_node as previous of new_node
    new_node->prev = prev_node;

    // Change previous of new_node's next node
    if (new_node->next != NULL)
        new_node->next->prev = new_node;
}

// Given a reference (pointer to pointer) to the head
// of a DLL and an int, appends a new node at the end
void append(Node** head_ref, int new_data)
{

    // Allocate node
    Node* new_node = new Node();

    Node* last = *head_ref;

    // Put in the data
    new_node->data = new_data;

    // This new node is going to be the last node,
    // so make next of it as NULL
    new_node->next = NULL;

    // If the Linked List is empty,
    // then make the new
    // node as head
    if (*head_ref == NULL) {
        new_node->prev = NULL;
        *head_ref = new_node;
        return;
    }

    // Else traverse till the last node
    while (last->next != NULL)
        last = last->next;

    // Change the next of last node
    last->next = new_node;

    // Make last node as previous of new node
    new_node->prev = last;

    return;
}

// This function prints contents of
// linked list starting from the given node
void printList(Node* node)
{
    Node* last;
    while (node != NULL) {
        cout << " " << node->data << " ";
        last = node;
        node = node->next;
    }
}

Node* reverseK(Node* head, int k)
{

    // When head is NULL or linked list
    // has a single node we return
    if (head == NULL || head->next == NULL)
        return head;

    // PrevFirst pointer keeps track of
    // the node that is to be connected to each
    // reversed part.
    Node *prevFirst = NULL, *curr = head;

    // FirstPass variable is used so that we
    // can mark head of the new linkedlist.
    bool firstPass = true;

    while (curr != NULL) {
        int count = 0;

        // Next keeps track of the next node of curr
        // Prev keeps track of the previous node of curr

        Node *first = curr, *next = NULL, *prev = NULL;
        while (curr != NULL && count < k) {

            // Reversing the doubly linked list by just
            // swapping their next and prev pointers
            next = curr->next;
            if (count == 0)
                curr->next = NULL;
            else
                curr->next = curr->prev;
            curr->prev = next;
            prev = curr;
            curr = next;
            count++;
        }
        if (firstPass) {

            // Setting the head of the new linkedlist
            head = next->prev;
            firstPass = false;
        }
        else {
            prevFirst->next = prev;
        }
        prevFirst = first;
    }
    return head;
}

// Driver Code
int main()
{

    // Start with the empty list
    Node* head = NULL;

    // Insert 6. So linked list becomes 6->NULL
    append(&head, 6);

    // Insert 7 at the beginning. So
    // linked list becomes 7->6->NULL
    push(&head, 7);

    // Insert 1 at the beginning. So
    // linked list becomes 1->7->6->NULL
    push(&head, 1);

    // Insert 4 at the end. So linked
    // list becomes 1->7->6->4->NULL
    append(&head, 4);

    // Insert 8, after 7. So linked
    // list becomes 1->7->8->6->4->NULL
    insertAfter(head->next, 8);

    // list becomes 1->7->8->6->4->9->NULL
    append(&head, 9);
    head = reverseK(head, 2);
    printList(head);

    return 0;
}