Related Articles

# Find the common nodes in two singly linked list

• Difficulty Level : Medium
• Last Updated : 30 Jun, 2021

Given two linked list, the task is to find the number of common nodes in both singly linked list.

Examples:

Input: List A = 3 -> 4 -> 12 -> 10 -> 17, List B = 10 -> 4 -> 8 -> 575 -> 34 -> 12
Output: Number of common nodes in both list is = 3

Input: List A = 12 -> 4 -> 65 -> 14 -> 59, List B = 14 -> 15 -> 23 -> 17 -> 41 -> 54
Output: Number of common nodes in both list is = 1

Naive Approach: Compare every node of list A with every node of list B. If the node is a match then increment the count and return count after all the nodes get compared.

Below is the implementation of above approach:

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;` `// Structure of a linked list node``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `// Function to common nodes which have``// same value node(s) both list``int` `countCommonNodes(``struct` `Node* head1, ``struct` `Node* head2)``{``    ``// list A``    ``struct` `Node* current1 = head1;` `    ``// list B``    ``struct` `Node* current2 = head2;` `    ``// set count = 0``    ``int` `count = 0;` `    ``// traverse list A till the end of list``    ``while` `(current1 != NULL) {` `        ``// traverse list B till the end of list``        ``while` `(current2 != NULL) {` `            ``// if data is match then count increase``            ``if` `(current1->data == current2->data)``                ``count++;` `            ``// increase current pointer for next node``            ``current2 = current2->next;``        ``}` `        ``// increase current pointer of list A``        ``current1 = current1->next;` `        ``// initialize list B starting point``        ``current2 = head2;``    ``}` `    ``// return count``    ``return` `count;``}` `/* Utility function to insert a node at the beginning */``void` `push(``struct` `Node** head_ref, ``int` `new_data)``{``    ``struct` `Node* new_node = ``new` `Node;``    ``new_node->data = new_data;``    ``new_node->next = *head_ref;``    ``*head_ref = new_node;``}` `/* Utility function to print a linked list */``void` `printList(``struct` `Node* head)``{``    ``while` `(head != NULL) {``        ``cout << head->data << ``" "``;``        ``head = head->next;``    ``}``    ``cout << endl;``}` `/* Driver program to test above functions */``int` `main()``{``    ``struct` `Node* head1 = NULL;``    ``struct` `Node* head2 = NULL;` `    ``/* Create following linked list``    ``List A = 3 -> 4 -> 12 -> 10 -> 17``*/` `    ``push(&head1, 17);``    ``push(&head1, 10);``    ``push(&head1, 12);``    ``push(&head1, 4);``    ``push(&head1, 3);` `    ``// List B = 10 -> 4 -> 8 -> 575 -> 34 -> 12``    ``push(&head2, 12);``    ``push(&head2, 34);``    ``push(&head2, 575);``    ``push(&head2, 8);``    ``push(&head2, 4);``    ``push(&head2, 10);` `    ``// print list A``    ``cout << ``"Given Linked List A: \n"``;``    ``printList(head1);` `    ``// print list B``    ``cout << ``"Given Linked List B: \n"``;``    ``printList(head2);` `    ``// call function for count common node``    ``int` `count = countCommonNodes(head1, head2);` `    ``// print number of common node in both list``    ``cout << ``"Number of common node in both list is = "` `<< count;``    ``return` `0;``}`

## Java

 `// Java implementation of above approach``class` `GFG {` `    ``// Structure of a linked list node``    ``static` `class` `Node {``        ``int` `data;``        ``Node next;``    ``};` `    ``// Function to common nodes which have``    ``// same value node(s) both list``    ``static` `int` `countCommonNodes(Node head1, Node head2)``    ``{``        ``// list A``        ``Node current1 = head1;` `        ``// list B``        ``Node current2 = head2;` `        ``// set count = 0``        ``int` `count = ``0``;` `        ``// traverse list A till the end of list``        ``while` `(current1 != ``null``) {` `            ``// traverse list B till the end of list``            ``while` `(current2 != ``null``) {` `                ``// if data is match then count increase``                ``if` `(current1.data == current2.data)``                    ``count++;` `                ``// increase current pointer for next node``                ``current2 = current2.next;``            ``}` `            ``// increase current pointer of list A``            ``current1 = current1.next;` `            ``// initialize list B starting point``            ``current2 = head2;``        ``}` `        ``// return count``        ``return` `count;``    ``}` `    ``// Utility function to insert a node at the beginning /``    ``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;``    ``}` `    ``// Utility function to print a linked list``    ``static` `void` `printList(Node head)``    ``{``        ``while` `(head != ``null``) {``            ``System.out.print(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``System.out.println();``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``Node head1 = ``null``;``        ``Node head2 = ``null``;` `        ``// Create following linked list``        ``// List A = 3 . 4 . 12 . 10 . 17` `        ``head1 = push(head1, ``17``);``        ``head1 = push(head1, ``10``);``        ``head1 = push(head1, ``12``);``        ``head1 = push(head1, ``4``);``        ``head1 = push(head1, ``3``);` `        ``// List B = 10 . 4 . 8 . 575 . 34 . 12``        ``head2 = push(head2, ``12``);``        ``head2 = push(head2, ``34``);``        ``head2 = push(head2, ``575``);``        ``head2 = push(head2, ``8``);``        ``head2 = push(head2, ``4``);``        ``head2 = push(head2, ``10``);` `        ``// print list A``        ``System.out.print(``"Given Linked List A: \n"``);``        ``printList(head1);` `        ``// print list B``        ``System.out.print(``"Given Linked List B: \n"``);``        ``printList(head2);` `        ``// call function for count common node``        ``int` `count = countCommonNodes(head1, head2);` `        ``// print number of common node in both list``        ``System.out.print(``"Number of common node in both list is = "` `+ count);``    ``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 implementation of above approach` `# Link list node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `# Function to common nodes which have``# same value node(s) both list``def` `countCommonNodes(head1, head2):``    ` `    ``# list A``    ``current1 ``=` `head1` `    ``# list B``    ``current2 ``=` `head2` `    ``# set count = 0``    ``count ``=` `0` `    ``# traverse list A till the end of list``    ``while` `(current1 !``=` `None``):` `        ``# traverse list B till the end of list``        ``while` `(current2 !``=` `None``):` `            ``# if data is match then count increase``            ``if` `(current1.data ``=``=` `current2.data):``                ``count ``=` `count ``+` `1` `            ``# increase current pointer for next node``            ``current2 ``=` `current2.``next``        ` `        ``# increase current pointer of list A``        ``current1 ``=` `current1.``next` `        ``# initialize list B starting point``        ``current2 ``=` `head2``    ` `    ``# return count``    ``return` `count` `# Utility function to insert a node at the beginning``def` `push(head_ref, new_data):``    ``new_node ``=` `Node(``0``)``    ``new_node.data ``=` `new_data``    ``new_node.``next` `=` `head_ref``    ``head_ref ``=` `new_node``    ``return` `head_ref` `# Utility function to print a linked list``def` `printList( head):``    ``while` `(head !``=` `None``):``        ``print``(head.data, end ``=` `" "``)``        ``head ``=` `head.``next``    ` `    ``print``("")` `# Driver Code``if` `__name__``=``=``'__main__'``:` `    ``head1 ``=` `None``    ``head2 ``=` `None` `    ``# Create following linked list``    ``# List A = 3 . 4 . 12 . 10 . 17``    ``head1 ``=` `push(head1, ``17``)``    ``head1 ``=` `push(head1, ``10``)``    ``head1 ``=` `push(head1, ``12``)``    ``head1 ``=` `push(head1, ``4``)``    ``head1 ``=` `push(head1, ``3``)` `    ``# List B = 10 . 4 . 8 . 575 . 34 . 12``    ``head2 ``=` `push(head2, ``12``)``    ``head2 ``=` `push(head2, ``34``)``    ``head2 ``=` `push(head2, ``575``)``    ``head2 ``=` `push(head2, ``8``)``    ``head2 ``=` `push(head2, ``4``)``    ``head2 ``=` `push(head2, ``10``)` `    ``# print list A``    ``print``(``"Given Linked List A: "``)``    ``printList(head1)` `    ``# print list B``    ``print``(``"Given Linked List B: "``)``    ``printList(head2)` `    ``# call function for count common node``    ``count ``=` `countCommonNodes(head1, head2)` `    ``# print number of common node in both list``    ``print``(``"Number of common node in both list is = "``, count)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG {` `    ``// Structure of a linked list node``    ``public` `class` `Node {``        ``public` `int` `data;``        ``public` `Node next;``    ``};` `    ``// Function to common nodes which have``    ``// same value node(s) both list``    ``static` `int` `countCommonNodes(Node head1, Node head2)``    ``{``        ``// list A``        ``Node current1 = head1;` `        ``// list B``        ``Node current2 = head2;` `        ``// set count = 0``        ``int` `count = 0;` `        ``// traverse list A till the end of list``        ``while` `(current1 != ``null``) {` `            ``// traverse list B till the end of list``            ``while` `(current2 != ``null``) {` `                ``// if data is match then count increase``                ``if` `(current1.data == current2.data)``                    ``count++;` `                ``// increase current pointer for next node``                ``current2 = current2.next;``            ``}` `            ``// increase current pointer of list A``            ``current1 = current1.next;` `            ``// initialize list B starting point``            ``current2 = head2;``        ``}` `        ``// return count``        ``return` `count;``    ``}` `    ``// Utility function to insert a node at the beginning /``    ``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;``    ``}` `    ``// Utility function to print a linked list``    ``static` `void` `printList(Node head)``    ``{``        ``while` `(head != ``null``) {``            ``Console.Write(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``Console.WriteLine();``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``Node head1 = ``null``;``        ``Node head2 = ``null``;` `        ``// Create following linked list``        ``// List A = 3 . 4 . 12 . 10 . 17` `        ``head1 = push(head1, 17);``        ``head1 = push(head1, 10);``        ``head1 = push(head1, 12);``        ``head1 = push(head1, 4);``        ``head1 = push(head1, 3);` `        ``// List B = 10 . 4 . 8 . 575 . 34 . 12``        ``head2 = push(head2, 12);``        ``head2 = push(head2, 34);``        ``head2 = push(head2, 575);``        ``head2 = push(head2, 8);``        ``head2 = push(head2, 4);``        ``head2 = push(head2, 10);` `        ``// print list A``        ``Console.Write(``"Given Linked List A: \n"``);``        ``printList(head1);` `        ``// print list B``        ``Console.Write(``"Given Linked List B: \n"``);``        ``printList(head2);` `        ``// call function for count common node``        ``int` `count = countCommonNodes(head1, head2);` `        ``// print number of common node in both list``        ``Console.Write(``"Number of common node in both list is = "` `+ count);``    ``}``}` `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``
Output:
```Given Linked List A:
3 4 12 10 17
10 4 8 575 34 12
Number of common node in both list is = 3```

Time Complexity: O(M*N), where M is length of list A and N is length of list B
Efficient Solution: Insert all the nodes of linked list A in the unordered_set and then check for each node of linked list B in unordered_set. If found increment the count and return the count at the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;` `// Structure of a linked list node``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `// Function to common nodes which have``// same value node(s) both list``int` `countCommonNodes(``struct` `Node* head1, ``struct` `Node* head2)``{``    ``// list  A``    ``struct` `Node* current1 = head1;` `    ``// list B``    ``struct` `Node* current2 = head2;` `    ``// set count  = 0``    ``int` `count = 0;` `    ``// create unordered_set``    ``unordered_set<``int``> map;` `    ``// traverse list A till the end of list``    ``while` `(current1 != NULL) {` `        ``// insert list data in map``        ``map.insert(current1->data);` `        ``// increase current pointer of list A``        ``current1 = current1->next;``    ``}` `    ``while` `(current2 != NULL) {` `        ``// traverse list B till the end of list``        ``// if data match then increase count``        ``if` `(map.find(current2->data) != map.end())``            ``count++;` `        ``// increase current pointer of list B``        ``current2 = current2->next;``    ``}` `    ``// return count``    ``return` `count;``}` `/* Utility function to insert a node at the beginning */``void` `push(``struct` `Node** head_ref, ``int` `new_data)``{``    ``struct` `Node* new_node = ``new` `Node;``    ``new_node->data = new_data;``    ``new_node->next = *head_ref;``    ``*head_ref = new_node;``}` `/* Utility function to print a linked list */``void` `printList(``struct` `Node* head)``{``    ``while` `(head != NULL) {``        ``cout << head->data << ``" "``;``        ``head = head->next;``    ``}``    ``cout << endl;``}` `/* Driver program to test above functions */``int` `main()``{``    ``struct` `Node* head1 = NULL;``    ``struct` `Node* head2 = NULL;` `    ``/* Create following linked list``    ``List A = 3 -> 4 -> 12 -> 10 -> 17``   ``*/` `    ``push(&head1, 17);``    ``push(&head1, 10);``    ``push(&head1, 12);``    ``push(&head1, 4);``    ``push(&head1, 3);` `    ``// List B = 10 -> 4 -> 8 -> 575 -> 34 -> 12``    ``push(&head2, 12);``    ``push(&head2, 34);``    ``push(&head2, 575);``    ``push(&head2, 8);``    ``push(&head2, 4);``    ``push(&head2, 10);` `    ``// print list A``    ``cout << ``"Given Linked List A: \n"``;``    ``printList(head1);` `    ``// print list B``    ``cout << ``"Given Linked List B: \n"``;``    ``printList(head2);` `    ``// call function for count common node``    ``int` `count = countCommonNodes(head1, head2);` `    ``// print number of common node in both list``    ``cout << ``"Number of common node in both list is = "` `<< count;` `    ``return` `0;``}`

## Java

 `// Java implementation of above approach``import` `java.util.*;``class` `solution {` `    ``// static class of a linked list node``    ``static` `class` `Node {``        ``int` `data;``        ``Node next;``    ``}` `    ``// Function to common nodes which have``    ``// same value node(s) both list``    ``static` `int` `countCommonNodes(Node head1, Node head2)``    ``{``        ``// list  A``        ``Node current1 = head1;` `        ``// list B``        ``Node current2 = head2;` `        ``// set count  = 0``        ``int` `count = ``0``;` `        ``// create vector``        ``Vector map = ``new` `Vector();` `        ``// traverse list A till the end of list``        ``while` `(current1 != ``null``) {` `            ``// insert list data in map``            ``map.add(current1.data);` `            ``// increase current pointer of list A``            ``current1 = current1.next;``        ``}` `        ``while` `(current2 != ``null``) {` `            ``// traverse list B till the end of list``            ``// if data match then increase count``            ``if` `(map.contains(current2.data))``                ``count++;` `            ``// increase current pointer of list B``            ``current2 = current2.next;``        ``}` `        ``// return count``        ``return` `count;``    ``}` `    ``/* Utility function to insert a node at the beginning */``    ``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;``    ``}` `    ``/* Utility function to print a linked list */``    ``static` `void` `printList(Node head)``    ``{``        ``while` `(head != ``null``) {``            ``System.out.print(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``System.out.println();``    ``}` `    ``/* Driver program to test above functions */``    ``public` `static` `void` `main(String args[])``    ``{``        ``Node head1 = ``null``;``        ``Node head2 = ``null``;` `        ``/* Create following linked list``    ``List A = 3 . 4 . 12 . 10 . 17``   ``*/` `        ``head1 = push(head1, ``17``);``        ``head1 = push(head1, ``10``);``        ``head1 = push(head1, ``12``);``        ``head1 = push(head1, ``4``);``        ``head1 = push(head1, ``3``);` `        ``// List B = 10 . 4 . 8 . 575 . 34 . 12``        ``head2 = push(head2, ``12``);``        ``head2 = push(head2, ``34``);``        ``head2 = push(head2, ``575``);``        ``head2 = push(head2, ``8``);``        ``head2 = push(head2, ``4``);``        ``head2 = push(head2, ``10``);` `        ``// print list A``        ``System.out.print(``"Given Linked List A: \n"``);``        ``printList(head1);` `        ``// print list B``        ``System.out.print(``"Given Linked List B: \n"``);``        ``printList(head2);` `        ``// call function for count common node``        ``int` `count = countCommonNodes(head1, head2);` `        ``// print number of common node in both list``        ``System.out.print(``"Number of common node in both list is = "` `+ count);``    ``}``}``// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 implementation of the approach` `# Structure of a linked list node``class` `Node:``    ``def` `__init__(``self``):``        ``self``.data ``=` `0``        ``self``.``next` `=` `None` `# Function to common nodes which have``# same value node(s) both list``def` `countCommonNodes(head1, head2):` `    ``# List A``    ``current1 ``=` `head1` `    ``# List B``    ``current2 ``=` `head2` `    ``# Set count = 0``    ``count ``=` `0` `    ``# Create unordered_set``    ``map_``=``set``()` `    ``# Traverse list A till the end of list``    ``while` `(current1 !``=` `None``) :` `        ``# Add list data in map_``        ``map_.add(current1.data)` `        ``# Increase current pointer of list A``        ``current1 ``=` `current1.``next``    ` `    ``while` `(current2 !``=` `None``) :` `        ``# Traverse list B till the end of list``        ``# if data match then increase count``        ``if` `((current2.data) ``in` `map_):``            ``count ``=` `count ``+` `1` `        ``# Increase current pointer of list B``        ``current2 ``=` `current2.``next``    ` `    ``# Return count``    ``return` `count` `# Utility function to add a node at the beginning``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` `# Utility function to print a linked list``def` `printList(head):``    ``while` `(head !``=` `None``) :``        ``print``(head.data, end ``=` `" "``)``        ``head ``=` `head.``next``    ` `# Driver program to test above functions``head1 ``=` `None``head2 ``=` `None` `# Create following linked list``# List A = 3 . 4 . 12 . 10 . 17``head1 ``=` `push(head1, ``17``)``head1 ``=` `push(head1, ``10``)``head1 ``=` `push(head1, ``12``)``head1 ``=` `push(head1, ``4``)``head1 ``=` `push(head1, ``3``)` `# List B = 10 . 4 . 8 . 575 . 34 . 12``head2 ``=` `push(head2, ``12``)``head2 ``=` `push(head2, ``34``)``head2 ``=` `push(head2, ``575``)``head2 ``=` `push(head2, ``8``)``head2 ``=` `push(head2, ``4``)``head2 ``=` `push(head2, ``10``)` `# Print list A``print``(``"Given Linked List A: "``)``printList(head1)` `# Print list B``print``( ``"\nGiven Linked List B: "``)``printList(head2)` `# Call function for count common node``count ``=` `countCommonNodes(head1, head2)` `# Print number of common node in both list``print``(``"\nNumber of common node in both list is = "` `, count)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `    ``// static class of a linked list node``    ``public` `class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node next;``    ``}` `    ``// Function to common nodes which have``    ``// same value node(s) both list``    ``static` `int` `countCommonNodes(Node head1, Node head2)``    ``{``        ``// list A``        ``Node current1 = head1;` `        ``// list B``        ``Node current2 = head2;` `        ``// set count = 0``        ``int` `count = 0;` `        ``// create vector``        ``List<``int``> map = ``new` `List<``int``>();` `        ``// traverse list A till the end of list``        ``while` `(current1 != ``null``)``        ``{` `            ``// insert list data in map``            ``map.Add(current1.data);` `            ``// increase current pointer of list A``            ``current1 = current1.next;``        ``}` `        ``while` `(current2 != ``null``)``        ``{` `            ``// traverse list B till the end of list``            ``// if data match then increase count``            ``if` `(map.Contains(current2.data))``                ``count++;` `            ``// increase current pointer of list B``            ``current2 = current2.next;``        ``}` `        ``// return count``        ``return` `count;``    ``}` `    ``/* Utility function to insert a node at the beginning */``    ``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;``    ``}` `    ``/* Utility function to print a linked list */``    ``static` `void` `printList(Node head)``    ``{``        ``while` `(head != ``null``)``        ``{``            ``Console.Write(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``Console.WriteLine();``    ``}` `    ``/* Driver code */``    ``public` `static` `void` `Main(String []args)``    ``{``        ``Node head1 = ``null``;``        ``Node head2 = ``null``;` `        ``/* Create following linked list``    ``List A = 3 . 4 . 12 . 10 . 17``*/` `        ``head1 = push(head1, 17);``        ``head1 = push(head1, 10);``        ``head1 = push(head1, 12);``        ``head1 = push(head1, 4);``        ``head1 = push(head1, 3);` `        ``// List B = 10 . 4 . 8 . 575 . 34 . 12``        ``head2 = push(head2, 12);``        ``head2 = push(head2, 34);``        ``head2 = push(head2, 575);``        ``head2 = push(head2, 8);``        ``head2 = push(head2, 4);``        ``head2 = push(head2, 10);` `        ``// print list A``        ``Console.Write(``"Given Linked List A: \n"``);``        ``printList(head1);` `        ``// print list B``        ``Console.Write(``"Given Linked List B: \n"``);``        ``printList(head2);` `        ``// call function for count common node``        ``int` `count = countCommonNodes(head1, head2);` `        ``// print number of common node in both list``        ``Console.Write(``"Number of common node in both list is = "` `+ count);``    ``}``}` `// This code has been contributed by 29AjayKumar`

## Javascript

 ``
Output:
```Given Linked List A:
3 4 12 10 17
10 4 8 575 34 12
Number of common node in both list is = 3```

Time Complexity: O(N)
Space Complexity: O(N)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up