# Find common elements in three linked lists

• Difficulty Level : Medium
• Last Updated : 09 Jan, 2023

Given three linked lists, find all common elements among the three linked lists.

Examples:

```Input :
10 15 20 25 12
10 12 13 15
10 12 15 24 25 26
Output : 10 12 15

Input :
1 2 3 4 5
1 2 3 4 6 9 8
1 2 4 5 10
Output : 1 2 4```

Method 1 : (Simple)
Use three-pointers to iterate the given three linked lists and if any element common print that element.
Time complexity of the above solution will be O(N*N*N)

Method 2 : (Use Merge Sort)

In this method, we first sort the three lists and then we traverse the sorted lists to get the intersection.

Following are the steps to be followed to get intersection of three lists:

1. Sort the first Linked List using merge sort. This step takes O(mLogm) time. Refer this post for details of this step.
2. Sort the second Linked List using merge sort. This step takes O(nLogn) time. Refer this post for details of this step.
3. Sort the third Linked List using merge sort. This step takes O(pLogp) time. Refer this post for details of this step.
4. Linearly scan three sorted lists to get the intersection. This step takes O(m + n + p) time. This step can be implemented using the same algorithm as sorted arrays algorithm discussed here.

Time complexity of this method is O(mLogm + nLogn + plogp) which is better than method 1â€™s time complexity.

Method 3 : (Hashing)

Following are the steps to be followed to get intersection of three lists using hashing:

1. Create an empty hash table. Iterate through the first linked list and mark all the element frequency as 1 in the hash table. This step takes O(m) time.
2. Iterate through the second linked list and if current element frequency is 1 in hash table mark it as 2. This step takes O(n) time.
3. Iterate the third linked list and if the current element frequency is 2 in hash table mark it as 3. This step takes O(p) time.
4. Now iterate first linked list again to check the frequency of elements. if an element with frequency three exist in hash table, it will be present in the intersection of three linked lists. This step takes O(m) time.

Time complexity of this method is O(m + n + p) which is better than time complexity of method 1 and 2.

Below is the implementation of the above idea.

## C++

 `// C++ program to find common element``// in three unsorted linked list``#include ``#define max 1000000``using` `namespace` `std;` `/* Link list node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `/* A utility function to insert a node at the``beginning of a linked list */``void` `push(``struct` `Node** head_ref, ``int` `new_data)``{``    ``struct` `Node* new_node =``            ``(``struct` `Node *)``malloc``(``sizeof``(``struct` `Node));``    ``new_node->data = new_data;``    ``new_node->next = (*head_ref);``    ``(*head_ref) = new_node;``}` `/* print the common element in between``given three linked list*/``void` `Common(``struct` `Node* head1,``            ``struct` `Node* head2, ``struct` `Node* head3)``{``    ` `    ``// Creating empty hash table;``    ``unordered_map<``int``, ``int``> hash;``    ` `    ``struct` `Node* p = head1;``    ``while` `(p != NULL) {``        ` `        ``// set frequency by 1``        ``hash[p->data] = 1;``        ``p = p->next;``    ``}``    ` `    ``struct` `Node* q = head2;``    ``while` `(q != NULL) {``        ` `        ``// if the element is already exist in the``        ``// linked list set its frequency 2``        ``if` `(hash.find(q->data) != hash.end())``            ``hash[q->data] = 2;``        ``q = q->next;``    ``}``    ` `    ``struct` `Node* r = head3;``    ``while` `(r != NULL) {``        ``if` `(hash.find(r->data) != hash.end() &&``            ``hash[r->data] == 2)``        ` `        ``// if the element frequency is 2 it means``        ``// its present in both the first and second``        ``// linked list set its frequency 3``        ``hash[r->data] = 3;``        ``r = r->next;``    ``}` `    ` `    ``for` `(``auto` `x : hash) {``        ` `        ``// if current frequency is 3 its means``        ``// element is common in all the given``        ``// linked list``        ``if` `(x.second == 3)``            ``cout << x.first << ``" "``;``    ``}``}` `// Driver code``int` `main()``{` `    ``// first list``    ``struct` `Node* head1 = NULL;``    ``push(&head1, 20);``    ``push(&head1, 5);``    ``push(&head1, 15);``    ``push(&head1, 10);` `    ``// second list``    ``struct` `Node* head2 = NULL;``    ``push(&head2, 10);``    ``push(&head2, 20);``    ``push(&head2, 15);``    ``push(&head2, 8);``        ` `    ``// third list``    ``struct` `Node* head3 = NULL;``    ``push(&head3, 10);``    ``push(&head3, 2);``    ``push(&head3, 15);``    ``push(&head3, 20);` `    ``Common(head1, head2, head3);``    ` `    ``return` `0;``}`

## Java

 `// Java program to find common element``// in three unsorted linked list``import` `java.util.*;` `class` `GFG``{``static` `int` `max = ``1000000``;` `/* Link list node */``static` `class` `Node``{``    ``int` `data;``    ``Node next;``};` `/* A utility function to insert a node``at the beginning of a linked list */``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;``}` `/* print the common element in between``given three linked list*/``static` `void` `Common(Node head1,``                   ``Node head2,``                   ``Node head3)``{``    ` `    ``// Creating empty hash table;``    ``HashMap hash = ``new` `HashMap();``    ` `    ``Node p = head1;``    ``while` `(p != ``null``)``    ``{``        ` `        ``// set frequency by 1``        ``hash. put(p.data, ``1``);``        ``p = p.next;``    ``}``    ` `    ``Node q = head2;``    ``while` `(q != ``null``)``    ``{``        ` `        ``// if the element is already exist in the``        ``// linked list set its frequency 2``        ``if` `(hash.containsKey(q.data))``            ``hash. put(q.data, ``2``);``        ``q = q.next;``    ``}``    ` `    ``Node r = head3;``    ``while` `(r != ``null``)``    ``{``        ``if` `(hash.containsKey(r.data)&&``            ``hash.get(r.data) == ``2``)``        ` `        ``// if the element frequency is 2 it means``        ``// its present in both the first and second``        ``// linked list set its frequency 3``        ``hash. put(r.data, ``3``);``        ``r = r.next;``    ``}` `    ``for` `(Map.Entry x : hash.entrySet())``    ``{``        ` `        ``// if current frequency is 3 its means``        ``// element is common in all the given``        ``// linked list``        ``if` `(x.getValue() == ``3``)``            ``System.out.println(x.getKey() + ``" "``);``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// first list``    ``Node head1 = ``null``;``    ``head1 = push(head1, ``20``);``    ``head1 = push(head1, ``5``);``    ``head1 = push(head1, ``15``);``    ``head1 = push(head1, ``10``);` `    ``// second list``    ``Node head2 = ``null``;``    ``head2 = push(head2, ``10``);``    ``head2 = push(head2, ``20``);``    ``head2 = push(head2, ``15``);``    ``head2 = push(head2, ``8``);``        ` `    ``// third list``    ``Node head3 = ``null``;``    ``head3 = push(head3, ``10``);``    ``head3 = push(head3, ``2``);``    ``head3 = push(head3, ``15``);``    ``head3 = push(head3, ``20``);` `    ``Common(head1, head2, head3);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to find common element``# in three unsorted linked list``max` `=` `1000000` `# Link list node``class` `Node:``    ` `    ``def` `__init__(``self``, data):``        ` `        ``self``.data ``=` `data``        ``self``.``next` `=` `None``        ` `# A utility function to insert a node at the``# beginning of a linked list``def` `push( head_ref, new_data):``    ` `    ``new_node ``=` `Node(new_data)``    ``new_node.``next` `=` `head_ref``    ``head_ref ``=` `new_node``    ``return` `head_ref` `# Print the common element in between``# given three linked list``def` `Common(head1, head2, head3):``     ` `    ``# Creating empty hash table;``    ``hash` `=` `dict``()``     ` `    ``p ``=` `head1``    ``while` `(p !``=` `None``):``        ` `        ``# Set frequency by 1``        ``hash``[p.data] ``=` `1``        ``p ``=` `p.``next``    ` `    ``q ``=` `head2``    ` `    ``while` `(q !``=` `None``):``        ` `        ``# If the element is already exist in the``        ``# linked list set its frequency 2``        ``if` `(q.data ``in` `hash``):``            ``hash``[q.data] ``=` `2``            ` `        ``q ``=` `q.``next` `    ``r ``=` `head3``    ` `    ``while` `(r !``=` `None``):``        ``if` `(r.data ``in` `hash``) ``and` `hash``[r.data] ``=``=` `2``:``            ` `            ``# If the element frequency is 2 it means``            ``# its present in both the first and second``            ``# linked list set its frequency 3``            ``hash``[r.data] ``=` `3``            ` `        ``r ``=` `r.``next``    ` `    ``for` `x ``in` `hash``.keys():``        ` `        ``# If current frequency is 3 its means``        ``# element is common in all the given``        ``# linked list``        ``if` `(``hash``[x] ``=``=` `3``):``            ``print``(x, end ``=` `' '``)``            ` `# Driver code``if` `__name__``=``=``'__main__'``:`` ` `    ``# First list``    ``head1 ``=` `None``    ``head1 ``=` `push(head1, ``20``)``    ``head1 ``=` `push(head1, ``5``)``    ``head1 ``=` `push(head1, ``15``)``    ``head1 ``=` `push(head1, ``10``)`` ` `    ``# Second list``    ``head2 ``=` `None``    ``head2 ``=` `push(head2, ``10``)``    ``head2 ``=` `push(head2, ``20``)``    ``head2 ``=` `push(head2, ``15``)``    ``head2 ``=` `push(head2, ``8``)``         ` `    ``# Third list``    ``head3 ``=` `None``    ``head3 ``=` `push(head3, ``10``)``    ``head3 ``=` `push(head3, ``2``)``    ``head3 ``=` `push(head3, ``15``)``    ``head3 ``=` `push(head3, ``20``)`` ` `    ``Common(head1, head2, head3)``     ` `# This code is contributed by rutvik_56`

## C#

 `// C# program to find common element``// in three unsorted linked list``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``static` `int` `max = 1000000;` `/* Link list node */``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``};` `/* A utility function to insert a node``at the beginning of a linked list */``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;``}` `/* print the common element in between``given three linked list*/``static` `void` `Common(Node head1,``                ``Node head2,``                ``Node head3)``{``    ` `    ``// Creating empty hash table;``    ``Dictionary<``int``,    ``               ``int``> hash = ``new` `Dictionary<``int``,``                                          ``int``>();``    ` `    ``Node p = head1;``    ``while` `(p != ``null``)``    ``{``        ` `        ``// set frequency by 1``        ``hash.Add(p.data, 1);``        ``p = p.next;``    ``}``    ` `    ``Node q = head2;``    ``while` `(q != ``null``)``    ``{``        ` `        ``// if the element is already exist in the``        ``// linked list set its frequency 2``        ``if` `(hash.ContainsKey(q.data))``            ``hash[q.data] = 2;``        ``q = q.next;``    ``}``    ` `    ``Node r = head3;``    ``while` `(r != ``null``)``    ``{``        ``if` `(hash.ContainsKey(r.data)&&``            ``hash[r.data] == 2)``        ` `        ``// if the element frequency is 2 it means``        ``// its present in both the first and``        ``// second linked list set its frequency 3``        ``hash[r.data] = 3;``        ``r = r.next;``    ``}` `    ``foreach``(KeyValuePair<``int``, ``int``> x ``in` `hash)``    ``{``        ` `        ``// if current frequency is 3 its means``        ``// element is common in all the given``        ``// linked list``        ``if` `(x.Value == 3)``            ``Console.Write(x.Key + ``" "``);``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// first list``    ``Node head1 = ``null``;``    ``head1 = push(head1, 20);``    ``head1 = push(head1, 5);``    ``head1 = push(head1, 15);``    ``head1 = push(head1, 10);` `    ``// second list``    ``Node head2 = ``null``;``    ``head2 = push(head2, 10);``    ``head2 = push(head2, 20);``    ``head2 = push(head2, 15);``    ``head2 = push(head2, 8);``        ` `    ``// third list``    ``Node head3 = ``null``;``    ``head3 = push(head3, 10);``    ``head3 = push(head3, 2);``    ``head3 = push(head3, 15);``    ``head3 = push(head3, 20);` `    ``Common(head1, head2, head3);``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

`10 15 20`

Time Complexity : O(m + n + p)
Auxiliary Space : O(m + n + p)

My Personal Notes arrow_drop_up