C++ Program To Merge A Linked List Into Another Linked List At Alternate Positions

Given two linked lists, insert nodes of second list into first list at alternate positions of first list. 
For example, if first list is 5->7->17->13->11 and second is 12->10->2->4->6, the first list should become 5->12->7->10->17->2->13->4->11->6 and second list should become empty. The nodes of second list should only be inserted when there are positions available. For example, if the first list is 1->2->3 and second list is 4->5->6->7->8, then first list should become 1->4->2->5->3->6 and second list to 7->8.
Use of extra space is not allowed (Not allowed to create additional nodes), i.e., insertion must be done in-place. Expected time complexity is O(n) where n is number of nodes in first list.

The idea is to run a loop while there are available positions in first loop and insert nodes of second list by changing pointers. Following are implementations of this approach. 

C++

// C++ program to merge a linked list
// into another at alternate positions
#include <bits/stdc++.h>
using namespace std;

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

/* Function to insert a node
   at the beginning */
void push(Node ** head_ref,
          int new_data)
{
    Node* new_node = new Node();
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}

/* Utility function to print a
   singly linked list */
void printList(Node *head)
{
    Node *temp = head;
    while (temp != NULL)
    {
        cout << temp -> data << " ";
        temp = temp -> next;
    }
    cout << endl;
}

// Main function that inserts nodes of
// linked list q into p at alternate positions.
// Since head of first list never changes and
// head of second list may change, we need single
// pointer for first list and double pointer for
// second list.
void merge(Node *p, Node **q)
{
    Node *p_curr = p, *q_curr = *q;
    Node *p_next, *q_next;

    // While there are available positions
    // in p
    while (p_curr != NULL &&
           q_curr != NULL)
    {
        // Save next pointers
        p_next = p_curr->next;
        q_next = q_curr->next;

        // Make q_curr as next of p_curr
        // Change next pointer of q_curr
        q_curr->next = p_next;

        // Change next pointer of p_curr
        p_curr->next = q_curr;

        // Update current pointers for
        // next iteration
        p_curr = p_next;
        q_curr = q_next;
    }

    // Update head pointer of second list
    *q = q_curr;
}

// Driver code
int main()
{
    Node *p = NULL, *q = NULL;
    push(&p, 3);
    push(&p, 2);
    push(&p, 1);
    cout << "First Linked List:";
    printList(p);

    push(&q, 8);
    push(&q, 7);
    push(&q, 6);
    push(&q, 5);
    push(&q, 4);
    cout << "Second Linked List:";
    printList(q);

    merge(p, &q);

    cout <<
    "Modified First Linked List:";
    printList(p);

    cout <<
    "Modified Second Linked List:";
    printList(q);

    return 0;
}
// This code is contributed by rathbhupendra

Output:

First Linked List:
1 2 3
Second Linked List:
4 5 6 7 8
Modified First Linked List:
1 4 2 5 3 6
Modified Second Linked List:
7 8 

Time Complexity: O(min(n1, n2)), where n1 and n2  represents the length of the given two linked lists.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Please refer complete article on Merge a linked list into another linked list at alternate positions for more details!