# Remove the common nodes in two Singly Linked Lists

Given two Linked Lists L1 and L2, the task is to generate a new linked list with no common elements from the given two linked lists.

Example:

Input: L1 = 10 -> 15 -> 5 -> 20, L2 = 8 -> 5 -> 20 -> 10
Output: 8 -> 15
Explanation:
Since both the linked list has 5, 10 and 20 in common. Therefore these elements are removed and the resultant list is 8 -> 15.

Input: L1 = 0 -> 5 -> 52 -> 21, L2 = 21 -> 5 -> 0 -> 52
Output: [ ]
Explanation:
Since all the elements of the two given linked list are common. So the resultant linked is empty.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. For each element(say X) in the first linked list:
• Traverse the second linked list and check if X is present in the linked list or not.
• If X is not present, then insert X in the resultant linked list as it not common in both linked list.
2. For each element(say Y) in the second linked list:
• Traverse the first linked list and check if Y is present in the linked list or not.
• If Y is not present, then insert Y in the resultant linked list as it not common in both linked list.
3. The resultant linked list will be the required linked list with no nodes common from the given two linked list.

Below is the implementation of the above approach:

## CPP

 `// C++ program for the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Link list node ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `// Function to print the element ` `// of the Linked List ` `void` `printList(``struct` `Node* p) ` `{ ` `    ``if` `(p == NULL) { ` `        ``cout << ``"[]"``; ` `    ``} ` ` `  `    ``while` `(p != NULL) { ` `        ``cout << p->data << ``" -> "``; ` `        ``p = p->next; ` `    ``} ` `} ` ` `  `// Function to push the node at the ` `// beginning of the linked list ` `void` `push(``struct` `Node** head_ref, ` `          ``int` `new_data) ` `{ ` `    ``struct` `Node* new_node ` `        ``= (``struct` `Node*)``malloc``( ` `            ``sizeof``(``struct` `Node)); ` ` `  `    ``new_node->data = new_data; ` `    ``new_node->next = (*head_ref); ` `    ``(*head_ref) = new_node; ` `} ` ` `  `// Function to insert unique ` `// elements in the new LL ` `void` `traverse(``struct` `Node** head3, ` `              ``struct` `Node* temp1, ` `              ``struct` `Node* temp2) ` `{ ` ` `  `    ``// Traverse the first linked list ` `    ``while` `(temp1 != NULL) { ` ` `  `        ``// Value of current node ` `        ``int` `val = temp1->data; ` `        ``struct` `Node* t = temp2; ` `        ``int` `x = 0; ` ` `  `        ``// Traverse the second list ` `        ``while` `(t != NULL) { ` `            ``if` `(t->data == val) { ` `                ``x = 1; ` `                ``break``; ` `            ``} ` `            ``t = t->next; ` `        ``} ` ` `  `        ``// If element is not common ` `        ``// then insert it in the ` `        ``// resultant linked list ` `        ``if` `(x == 0) { ` `            ``push(head3, temp1->data); ` `        ``} ` ` `  `        ``temp1 = temp1->next; ` `    ``} ` `} ` ` `  `// Function to remove the common nodes ` `// in two Singly Linked Lists ` `void` `removeCommonNodes(``struct` `Node* head1, ` `                       ``struct` `Node* head2) ` `{ ` ` `  `    ``// Head pointer for the resultant ` `    ``// linked list ` `    ``struct` `Node* head3 = NULL; ` ` `  `    ``// Find the node common between ` `    ``// linked list taking head1 as ` `    ``// first linked list ` `    ``traverse(&head3, head1, head2); ` ` `  `    ``// Find the node common between ` `    ``// linked list taking head2 as ` `    ``// first linked list ` `    ``traverse(&head3, head2, head1); ` ` `  `    ``// Print the resultant linked list ` `    ``printList(head3); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// First list ` `    ``struct` `Node* head1 = NULL; ` `    ``push(&head1, 20); ` `    ``push(&head1, 5); ` `    ``push(&head1, 15); ` `    ``push(&head1, 10); ` ` `  `    ``// Second list ` `    ``struct` `Node* head2 = NULL; ` `    ``push(&head2, 10); ` `    ``push(&head2, 20); ` `    ``push(&head2, 15); ` `    ``push(&head2, 8); ` ` `  `    ``// Function call ` `    ``removeCommonNodes(head1, head2); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `class` `GFG{ ` `  `  `// Link list node ` `static` `class` `Node { ` `    ``int` `data; ` `    ``Node next; ` `}; ` `  `  `// Function to print the element ` `// of the Linked List ` `static` `void` `printList(Node p) ` `{ ` `    ``if` `(p == ``null``) { ` `        ``System.out.print(``"[]"``); ` `    ``} ` `  `  `    ``while` `(p != ``null``) { ` `        ``System.out.print(p.data+ ``"->"``); ` `        ``p = p.next; ` `    ``} ` `} ` `  `  `// Function to push the node at the ` `// beginning of the linked list ` `static` `Node 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; ` `    ``return` `head_ref; ` `} ` `  `  `// Function to insert unique ` `// elements in the new LL ` `static` `Node traverse(Node head3, ` `              ``Node temp1, ` `              ``Node temp2) ` `{ ` `  `  `    ``// Traverse the first linked list ` `    ``while` `(temp1 != ``null``) { ` `  `  `        ``// Value of current node ` `        ``int` `val = temp1.data; ` `        ``Node t = temp2; ` `        ``int` `x = ``0``; ` `  `  `        ``// Traverse the second list ` `        ``while` `(t != ``null``) { ` `            ``if` `(t.data == val) { ` `                ``x = ``1``; ` `                ``break``; ` `            ``} ` `            ``t = t.next; ` `        ``} ` `  `  `        ``// If element is not common ` `        ``// then insert it in the ` `        ``// resultant linked list ` `        ``if` `(x == ``0``) { ` `            ``head3 = push(head3, temp1.data); ` `        ``} ` `  `  `        ``temp1 = temp1.next; ` `    ``} ` `    ``return` `head3; ` `} ` `  `  `// Function to remove the common nodes ` `// in two Singly Linked Lists ` `static` `void` `removeCommonNodes(Node head1, ` `                       ``Node head2) ` `{ ` `  `  `    ``// Head pointer for the resultant ` `    ``// linked list ` `    ``Node head3 = ``null``; ` `  `  `    ``// Find the node common between ` `    ``// linked list taking head1 as ` `    ``// first linked list ` `    ``head3 = traverse(head3, head1, head2); ` `  `  `    ``// Find the node common between ` `    ``// linked list taking head2 as ` `    ``// first linked list ` `    ``head3 = traverse(head3, head2, head1); ` `  `  `    ``// Print the resultant linked list ` `    ``printList(head3); ` `} ` `  `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// First list ` `    ``Node head1 = ``new` `Node(); ` `    ``head1 = push(head1, ``20``); ` `    ``head1 = push(head1, ``5``); ` `    ``head1 = push(head1, ``15``); ` `    ``head1 = push(head1, ``10``); ` `  `  `    ``// Second list ` `    ``Node head2 = ``new` `Node(); ` `    ``head2 = push(head2, ``10``); ` `    ``head2 = push(head2, ``20``); ` `    ``head2 = push(head2, ``15``); ` `    ``head2 = push(head2, ``8``); ` `  `  `    ``// Function call ` `    ``removeCommonNodes(head1, head2); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` `   `  `// Link list node ` `class` `Node { ` `    ``public` `int` `data; ` `    ``public` `Node next; ` `}; ` `   `  `// Function to print the element ` `// of the Linked List ` `static` `void` `printList(Node p) ` `{ ` `    ``if` `(p == ``null``) { ` `        ``Console.Write(``"[]"``); ` `    ``} ` `   `  `    ``while` `(p != ``null``) { ` `        ``Console.Write(p.data+ ``"->"``); ` `        ``p = p.next; ` `    ``} ` `} ` `   `  `// Function to push the node at the ` `// beginning of the linked list ` `static` `Node 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; ` `    ``return` `head_ref; ` `} ` `   `  `// Function to insert unique ` `// elements in the new LL ` `static` `Node traverse(Node head3, ` `              ``Node temp1, ` `              ``Node temp2) ` `{ ` `   `  `    ``// Traverse the first linked list ` `    ``while` `(temp1 != ``null``) { ` `   `  `        ``// Value of current node ` `        ``int` `val = temp1.data; ` `        ``Node t = temp2; ` `        ``int` `x = 0; ` `   `  `        ``// Traverse the second list ` `        ``while` `(t != ``null``) { ` `            ``if` `(t.data == val) { ` `                ``x = 1; ` `                ``break``; ` `            ``} ` `            ``t = t.next; ` `        ``} ` `   `  `        ``// If element is not common ` `        ``// then insert it in the ` `        ``// resultant linked list ` `        ``if` `(x == 0) { ` `            ``head3 = push(head3, temp1.data); ` `        ``} ` `   `  `        ``temp1 = temp1.next; ` `    ``} ` `    ``return` `head3; ` `} ` `   `  `// Function to remove the common nodes ` `// in two Singly Linked Lists ` `static` `void` `removeCommonNodes(Node head1, ` `                       ``Node head2) ` `{ ` `   `  `    ``// Head pointer for the resultant ` `    ``// linked list ` `    ``Node head3 = ``null``; ` `   `  `    ``// Find the node common between ` `    ``// linked list taking head1 as ` `    ``// first linked list ` `    ``head3 = traverse(head3, head1, head2); ` `   `  `    ``// Find the node common between ` `    ``// linked list taking head2 as ` `    ``// first linked list ` `    ``head3 = traverse(head3, head2, head1); ` `   `  `    ``// Print the resultant linked list ` `    ``printList(head3); ` `} ` `   `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``// First list ` `    ``Node head1 = ``new` `Node(); ` `    ``head1 = push(head1, 20); ` `    ``head1 = push(head1, 5); ` `    ``head1 = push(head1, 15); ` `    ``head1 = push(head1, 10); ` `   `  `    ``// Second list ` `    ``Node head2 = ``new` `Node(); ` `    ``head2 = push(head2, 10); ` `    ``head2 = push(head2, 20); ` `    ``head2 = push(head2, 15); ` `    ``head2 = push(head2, 8); ` `   `  `    ``// Function call ` `    ``removeCommonNodes(head1, head2); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```8 -> 5 ->
```

Time Complexity: O(M * N), where M and N are the lengths of the two given linked list.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.