# Remove the common nodes in two Singly Linked Lists

• Last Updated : 29 Oct, 2021

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.

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:

## C++

 `// 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`

## Python3

 `# Python3 program for the above approach`` ` `# Link list node``class` `Node:``    ` `    ``def` `__init__(``self``):``        ` `        ``self``.data ``=` `0``        ``self``.``next` `=` `None``    ` `# Function to print the element``# of the Linked List``def` `printList(p):``    ` `    ``if` `(p ``=``=` `None``):``        ``print``(``'[]'``, end ``=` `'')`` ` `    ``while` `(p !``=` `None``):``        ``print``(p.data, end ``=` `' -> '``)``        ``p ``=` `p.``next``    ` `# Function to push the node at the``# beginning of the linked list``def` `push(head_ref, new_data):``    ` `    ``new_node ``=` `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``def` `traverse(head3, temp1, temp2):``    ` `    ``# Traverse the first linked list``    ``while` `(temp1 !``=` `None``):``        ` `        ``# Value of current node``        ``val ``=` `temp1.data``        ``t ``=` `temp2``        ``x ``=` `0`` ` `        ``# Traverse the second list``        ``while` `(t !``=` `None``):``            ``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``def` `removeCommonNodes(head1, head2):``    ` `    ``# Head pointer for the resultant``    ``# linked list``    ``head3 ``=` `None`` ` `    ``# 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``if` `__name__``=``=``'__main__'``:``    ` `    ``# First list``    ``head1 ``=` `None``    ``head1 ``=` `push(head1, ``20``)``    ``head1 ``=` `push(head1, ``5``)``    ``head1 ``=` `push(head1, ``15``)``    ``head1 ``=` `push(head1, ``10``)`` ` `    ``# Second list``    ``head2 ``=` `None``    ``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 rutvik_56`

## 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`

## Javascript

 ``
Output:
`8 -> 5 ->`

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

My Personal Notes arrow_drop_up