Open In App

Find the common nodes in two singly linked list

Last Updated : 25 Sep, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

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

Complexity Analysis:

  • Time Complexity: O(M*N), where M is length of list A and N is length of list B
  • Auxiliary Space: O(1) because it is using constant space

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
JavaScript 
<script>
      // JavaScript implementation of above approach
      // static class of a linked list node
      class Node {
        constructor() {
          this.data = 0;
          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;

        // create vector
        var map = [];

        // traverse list A till the end of list
        while (current1 != null) {
          // insert list data in map
          map.push(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.includes(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 */
      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 print 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 rdtank.
    </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

Complexity Analysis:

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

Recursive Approach:

  • Check if either of the linked lists is empty (i.e., head1 or head2 is null), return 0 if either of them is empty.
  • Initialize a count variable to 0, and create a Node pointer temp to point to the head of the second linked list.
  • Traverse the second linked list using temp, comparing each node's data with the data of the current node of the first linked list (i.e., head1). If there is a match, increment the count.
  • Recursively call the countCommonNodes function, passing in the next node of the first linked list (i.e., head1->next) and the head of the second linked list (i.e., head2).
  • Add the count returned by the recursive call to the count variable.
  • Return the final count.

Below is the implementation of the above approach:

C++ 
#include <iostream>

using namespace std;

// Node structure
struct Node {
    int data;
    Node* next;
};

// Function to find the intersection of two linked lists recursively
int countCommonNodes(Node* head1, Node* head2) {
    // If either of the lists is empty, there can't be any common nodes
    if (head1 == nullptr || head2 == nullptr) {
        return 0;
    }
    
    // Check if the current node of the first list appears in the second list
    int count = 0;
    Node* temp = head2;
    while (temp != nullptr) {
        if (head1->data == temp->data) {
            count++;
        }
        temp = temp->next;
    }
    
    // Recursively check for common nodes in the rest of the lists
    return count + countCommonNodes(head1->next, head2);
}

// Function to create a new node
Node* newNode(int data) {
    Node* node = new Node;
    node->data = data;
    node->next = nullptr;
    return node;
}

void printList(struct Node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}
// Driver code
int main() {
    // Create first linked list
    Node* head1 = newNode(3);
    head1->next = newNode(4);
    head1->next->next = newNode(12);
    head1->next->next->next = newNode(10);
    head1->next->next->next->next = newNode(17);

    // Create second linked list
    Node* head2 = newNode(10);
    head2->next = newNode(4);
    head2->next->next = newNode(8);
    head2->next->next->next = newNode(575);
    head2->next->next->next->next = newNode(34);
    head2->next->next->next->next->next = newNode(12);

    // 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 
class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedListCommonNodes {
    public static int countCommonNodes(Node head1, Node head2) {
        // If either of the lists is empty, there can't be any common nodes
        if (head1 == null || head2 == null) {
            return 0;
        }

        // Check if the current node of the first list appears in the second list
        int count = 0;
        Node temp = head2;
        while (temp != null) {
            if (head1.data == temp.data) {
                count++;
            }
            temp = temp.next;
        }

        // Recursively check for common nodes in the rest of the lists
        return count + countCommonNodes(head1.next, head2);
    }

    public static void printList(Node head) {
        while (head != null) {
            System.out.print(head.data + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Create first linked list
        Node head1 = new Node(3);
        head1.next = new Node(4);
        head1.next.next = new Node(12);
        head1.next.next.next = new Node(10);
        head1.next.next.next.next = new Node(17);

        // Create second linked list
        Node head2 = new Node(10);
        head2.next = new Node(4);
        head2.next.next = new Node(8);
        head2.next.next.next = new Node(575);
        head2.next.next.next.next = new Node(34);
        head2.next.next.next.next.next = new Node(12);

        // Print list A
        System.out.println("Given Linked List A:");
        printList(head1);

        // Print list B
        System.out.println("Given Linked List B:");
        printList(head2);

        // Call function to count common nodes
        int count = countCommonNodes(head1, head2);

        // Print the number of common nodes in both lists
        System.out.println("Number of common nodes in both lists is = " + count);
    }
}
Python3 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def count_common_nodes(head1, head2):
    # If either of the lists is empty, there can't be any common nodes
    if head1 is None or head2 is None:
        return 0
    
    # Check if the current node of the first list appears in the second list
    count = 0
    temp = head2
    while temp is not None:
        if head1.data == temp.data:
            count += 1
        temp = temp.next
    
    # Recursively check for common nodes in the rest of the lists
    return count + count_common_nodes(head1.next, head2)

def print_list(head):
    while head is not None:
        print(head.data, end=" ")
        head = head.next
    print()

# Driver code
if __name__ == "__main__":
    # Create first linked list
    head1 = Node(3)
    head1.next = Node(4)
    head1.next.next = Node(12)
    head1.next.next.next = Node(10)
    head1.next.next.next.next = Node(17)

    # Create second linked list
    head2 = Node(10)
    head2.next = Node(4)
    head2.next.next = Node(8)
    head2.next.next.next = Node(575)
    head2.next.next.next.next = Node(34)
    head2.next.next.next.next.next = Node(12)

    # Print list A
    print("Given Linked List A:")
    print_list(head1)
 
    # Print list B
    print("Given Linked List B:")
    print_list(head2)
 
    # Call function to count common nodes
    count = count_common_nodes(head1, head2)
 
    # Print the number of common nodes in both lists
    print("Number of common nodes in both lists is =", count)
C# 
using System;

// Node structure
public class Node
{
    public int data;
    public Node next;
}

public class LinkedListIntersection
{
    // Function to find the intersection of two linked lists recursively
    public static int CountCommonNodes(Node head1, Node head2)
    {
        // If either of the lists is empty, there can't be any common nodes
        if (head1 == null || head2 == null)
        {
            return 0;
        }

        // Check if the current node of the first list appears in the second list
        int count = 0;
        Node temp = head2;
        while (temp != null)
        {
            if (head1.data == temp.data)
            {
                count++;
            }
            temp = temp.next;
        }

        // Recursively check for common nodes in the rest of the lists
        return count + CountCommonNodes(head1.next, head2);
    }

    // Function to create a new node
    public static Node NewNode(int data)
    {
        Node node = new Node();
        node.data = data;
        node.next = null;
        return node;
    }

    public 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)
    {
        // Create first linked list
        Node head1 = NewNode(3);
        head1.next = NewNode(4);
        head1.next.next = NewNode(12);
        head1.next.next.next = NewNode(10);
        head1.next.next.next.next = NewNode(17);

        // Create second linked list
        Node head2 = NewNode(10);
        head2.next = NewNode(4);
        head2.next.next = NewNode(8);
        head2.next.next.next = NewNode(575);
        head2.next.next.next.next = NewNode(34);
        head2.next.next.next.next.next = NewNode(12);

        // Print list A
        Console.WriteLine("Given Linked List A:");
        PrintList(head1);

        // Print list B
        Console.WriteLine("Given Linked List B:");
        PrintList(head2);

        // Call function for count common node
        int count = CountCommonNodes(head1, head2);

        // Print number of common nodes in both lists
        Console.WriteLine("Number of common nodes in both lists = " + count);
    }
}
JavaScript 
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

function countCommonNodes(head1, head2) {
    // If either of the lists is empty, there can't be any common nodes
    if (head1 === null || head2 === null) {
        return 0;
    }

    // Check if the current node of the first list appears in the second list
    let count = 0;
    let temp = head2;
    while (temp !== null) {
        if (head1.data === temp.data) {
            count++;
        }
        temp = temp.next;
    }

    // Recursively check for common nodes in the rest of the lists
    return count + countCommonNodes(head1.next, head2);
}

function printList(head) {
    while (head !== null) {
        process.stdout.write(head.data + " ");
        head = head.next;
    }
    console.log();
}

// Driver code
if (typeof require !== 'undefined' && require.main === module) {
    // Create first linked list
    const head1 = new Node(3);
    head1.next = new Node(4);
    head1.next.next = new Node(12);
    head1.next.next.next = new Node(10);
    head1.next.next.next.next = new Node(17);

    // Create second linked list
    const head2 = new Node(10);
    head2.next = new Node(4);
    head2.next.next = new Node(8);
    head2.next.next.next = new Node(575);
    head2.next.next.next.next = new Node(34);
    head2.next.next.next.next.next = new Node(12);

    // Print list A
    console.log("Given Linked List A:");
    printList(head1);

    // Print list B
    console.log("Given Linked List B:");
    printList(head2);

    // Call function to count common nodes
    const count = countCommonNodes(head1, head2);

    // Print the number of common nodes in both lists
    console.log("Number of common nodes in both lists is =", count);
}

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 and n are the lengths of the two lists respectively. This is because, for each node in the first list, we need to traverse the entire second list to check if there are any common nodes. 

Auxiliary Space: O(m+n), where m and n are the lengths of the two lists respectively. This is because we are using the call stack to keep track of the recursion, and the maximum depth of the recursion tree is m+n.


Next Article
Analysis of Algorithms

A
Amal Kumar Choubey
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox