Skip to content
Related Articles

Related Articles

Improve Article
Find the common nodes in two singly linked list
  • Difficulty Level : Medium
  • Last Updated : 28 May, 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 <bits/stdc++.h>
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




<script>
 
// Javascript implementation of above approach   
// Structure of a linked list node
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
 
// Function to common nodes which have
// same value node(s) both list
function countCommonNodes(head1, head2)
{
     
    // List A
    var current1 = head1;
 
    // List B
    var current2 = head2;
 
    // Set count = 0
    var 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
function push(head_ref, new_data)
{
    var new_node = new Node();
    new_node.data = new_data;
    new_node.next = head_ref;
    head_ref = new_node;
    return head_ref;
}
 
// Utility function to prvar a linked list
function printList(head)
{
    while (head != null)
    {
        document.write(head.data + " ");
        head = head.next;
    }
    document.write("<br/>");
}
 
// Driver code
var head1 = null;
var 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
document.write("Given Linked List A: <br/>");
printList(head1);
 
// Print list B
document.write("Given Linked List B: <br/>");
printList(head2);
 
// Call function for count common node
var count = countCommonNodes(head1, head2);
 
// Print number of common node in both list
document.write("Number of common node in both list is = " +
               count);
 
// This code is contributed by gauravrajput1
 
</script>
Output: 
Given Linked List A: 
3 4 12 10 17 
Given Linked List B: 
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 <bits/stdc++.h>
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<Integer> map = new Vector<Integer>();
 
        // 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 
Given Linked List B: 
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 industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :