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 begining */
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 begining /
    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 begining /
    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 begining */
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 begining */
    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 begining */
    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.



Improved By : andrew1234, princiraj1992