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++ 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!