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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
  
        // intialize 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
  
            // intialize 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
  
            // intialize 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 */

chevron_right


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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)



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.