# Find the common nodes in two singly linked list

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

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 `

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.

My Personal Notes arrow_drop_up 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.