# Union and Intersection of two linked lists | Set-3 (Hashing)

• Difficulty Level : Easy
• Last Updated : 11 Jun, 2022

Given two Linked Lists, create union and intersection lists that contain union and intersection of the elements present in the given lists. Order of elements in output lists doesn’t matter. Examples:

```Input:
List1: 10 -> 15 -> 4 -> 20
List2: 8 -> 4 -> 2 -> 10
Output:
Intersection List: 4 -> 10
Union List: 2 -> 8 -> 20 -> 4 -> 15 -> 10
Explanation: In this two lists 4 and 10 nodes
are common. The union lists contains
all the nodes of both the lists.

Input:
List1: 1 -> 2 -> 3 -> 4
List2: 3 -> 4 -> 8 -> 10
Output:
Intersection List: 3 -> 4
Union List: 1 -> 2 -> 3 -> 4 -> 8 -> 10
Explanation: In this two lists 4 and 3 nodes
are common. The union lists contains
all the nodes of both the lists.```

We have already discussed Method-1 and Method-2 of this question. In this post, its Method-3 (Using Hashing) is discussed with a Time Complexity of O(m+n) i.e. better than both methods discussed earlier.

```Implementation:
1- Start traversing both the lists.
a) Store the current element of both lists
with its occurrence in the map.
2- For Union: Store all the elements of the map
in the resultant list.
3- For Intersection: Store all the elements only
with an occurrence of 2 as 2 denotes that
they are present in both the lists.```

Below is the C++ implementation of the above steps.

## CPP

 `// C++ program to find union and intersection of` `// two unsorted linked lists in O(m+n) time.` `#include ` `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)` `{` `    ``/* allocate node */` `    ``struct` `Node* new_node = (``struct` `Node*)``malloc``(` `        ``sizeof``(``struct` `Node));`   `    ``/* put in the data */` `    ``new_node->data = new_data;`   `    ``/* link the old list off the new node */` `    ``new_node->next = (*head_ref);`   `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node;` `}`   `/* Utility function to store the ` `   ``elements of both list */` `void` `storeEle(``struct` `Node* head1, ``struct` `Node* head2,` `              ``unordered_map<``int``, ``int``>& eleOcc)` `{` `    ``struct` `Node* ptr1 = head1;` `    ``struct` `Node* ptr2 = head2;`   `    ``// Traverse both lists` `    ``while` `(ptr1 != NULL || ptr2 != NULL) {` `        ``// store element in the map` `        ``if` `(ptr1 != NULL) {` `            ``eleOcc[ptr1->data]++;` `            ``ptr1 = ptr1->next;` `        ``}`   `        ``// store element in the map` `        ``if` `(ptr2 != NULL) {` `            ``eleOcc[ptr2->data]++;` `            ``ptr2 = ptr2->next;` `        ``}` `    ``}` `}`   `/* Function to get the union of two ` `   ``linked lists head1 and head2 */` `struct` `Node* getUnion(` `    ``unordered_map<``int``, ``int``> eleOcc)` `{` `    ``struct` `Node* result = NULL;`   `    ``// Push all the elements into` `    ``// the resultant list` `    ``for` `(``auto` `it = eleOcc.begin(); it != eleOcc.end(); it++)` `        ``push(&result, it->first);`   `    ``return` `result;` `}`   `/* Function to get the intersection of ` `   ``two linked lists head1 and head2 */` `struct` `Node* getIntersection(` `    ``unordered_map<``int``, ``int``> eleOcc)` `{` `    ``struct` `Node* result = NULL;`   `    ``// Push a node with an element` `    ``// having occurrence of 2 as that` `    ``// means the current element is` `    ``// present in both the lists` `    ``for` `(``auto` `it = eleOcc.begin();` `         ``it != eleOcc.end(); it++)` `        ``if` `(it->second == 2)` `            ``push(&result, it->first);`   `    ``// return resultant list` `    ``return` `result;` `}`   `/* A utility function to print a linked list*/` `void` `printList(``struct` `Node* node)` `{` `    ``while` `(node != NULL) {` `        ``printf``("%d ", node->data);` `        ``node = node->next;` `    ``}` `}`   `// Prints union and intersection of` `// lists with head1 and head2.` `void` `printUnionIntersection(Node* head1,` `                            ``Node* head2)` `{` `    ``// Store all the elements of` `    ``// both lists in the map` `    ``unordered_map<``int``, ``int``> eleOcc;` `    ``storeEle(head1, head2, eleOcc);`   `    ``Node* intersection_list = getIntersection(eleOcc);` `    ``Node* union_list = getUnion(eleOcc);`   `    ``printf``("\nIntersection list is \n");` `    ``printList(intersection_list);`   `    ``printf``("\nUnion list is \n");` `    ``printList(union_list);` `}`   `/* Driver program to test above function*/` `int` `main()` `{` `    ``/* Start with the empty list */` `    ``struct` `Node* head1 = NULL;` `    ``struct` `Node* head2 = NULL;`   `    ``/* create a linked list 11->10->15->4->20 */` `    ``push(&head1, 1);` `    ``push(&head1, 2);` `    ``push(&head1, 3);` `    ``push(&head1, 4);` `    ``push(&head1, 5);`   `    ``/* create a linked list 8->4->2->10 */` `    ``push(&head2, 1);` `    ``push(&head2, 3);` `    ``push(&head2, 5);` `    ``push(&head2, 6);`   `    ``printf``("First list is \n");` `    ``printList(head1);`   `    ``printf``("\nSecond list is \n");` `    ``printList(head2);`   `    ``printUnionIntersection(head1, head2);`   `    ``return` `0;` `}`

## Java

 `//Java program to find union and intersection of` `// two unsorted linked lists in O(m+n) time.`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {` `    `  `    ``static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``System.out.print(node.data+``" "``);` `            ``node = node.next;` `        ``}` `    ``}` `    `  `    ``//Utility function to store the` `   ``//elements of both list` `    ``static` `void` `storeEle(Node head1, Node head2,Map eleOcc)` `    ``{` `        ``Node ptr1 = head1;` `        ``Node ptr2 = head2;` `     `  `        ``// Traverse both lists` `        ``while` `(ptr1 != ``null` `|| ptr2 != ``null``) {` `            ``// store element in the map` `            ``if` `(ptr1 != ``null``) {` `                ``if``(eleOcc.get(ptr1.data)==``null``){` `                    ``eleOcc.put(ptr1.data,``1``);` `                ``}``else``{` `                    ``eleOcc.put(ptr1.data,eleOcc.get(ptr1.data)+``1``);` `                ``}` `                ``ptr1 = ptr1.next;` `            ``}` `     `  `            ``// store element in the map` `            ``if` `(ptr2 != ``null``) {` `                ``if``(eleOcc.get(ptr2.data)==``null``){` `                    ``eleOcc.put(ptr2.data,``1``);` `                ``}``else``{` `                    ``eleOcc.put(ptr2.data,eleOcc.get(ptr2.data)+``1``);` `                ``}` `                ``ptr2 = ptr2.next;` `            ``}` `        ``}` `    ``}` `    `  `    ``//Function to get the union of two` `   ``//linked lists head1 and head2` `    ``static` `Node getUnion(Map eleOcc)` `    ``{` `        ``Node result = ``null``;` `     `  `        ``// Push all the elements into` `        ``// the resultant list` `        ``for` `(``int` `key:eleOcc.keySet()){` `            ``Node node = ``new` `Node(key);` `            ``node.next=result;` `            ``result=node;` `        ``}` `     `  `        ``return` `result;` `    ``}` `    `  `    ``// Prints union and intersection of` `    ``// lists with head1 and head2.` `    ``static` `void` `printUnionIntersection(Node head1,Node head2)` `    ``{` `        ``// Store all the elements of` `        ``// both lists in the map` `        ``Map eleOcc = ``new` `HashMap<>();` `        ``storeEle(head1, head2, eleOcc);` `     `  `        ``Node intersection_list = getIntersection(eleOcc);` `        ``Node union_list = getUnion(eleOcc);` `     `  `        ``System.out.println(``"\nIntersection list is: "``);` `        ``printList(intersection_list);` `     `  `        ``System.out.println(``"\nUnion list is: "``);` `        ``printList(union_list);` `    ``}` `    `  `    ``//Function to get the intersection of` `   ``//two linked lists head1 and head2` `    ``static` `Node getIntersection(Map eleOcc)` `    ``{` `        ``Node result = ``null``;` `     `  `        ``// Push a node with an element` `        ``// having occurrence of 2 as that` `        ``// means the current element is` `        ``// present in both the lists` `        ``for` `(``int` `key:eleOcc.keySet()){` `            ``if``(eleOcc.get(key)==``2``){` `                ``Node node = ``new` `Node(key);` `                ``node.next=result;` `                ``result=node;` `            ``}` `        ``}` `     `  `        ``// return resultant list` `        ``return` `result;` `    ``}` `    `  `    ``//Driver program to test above function` `    ``public` `static` `void` `main (String[] args) {` `        `  `        ``/* Start with the empty list */` `        ``LinkedList l1 = ``new` `LinkedList();` `        ``LinkedList l2 = ``new` `LinkedList();` `        `  `        ``/*create a linked list 11->10->15->4->20 */` `        ``l1.push(``1``);` `        ``l1.push(``2``);` `        ``l1.push(``3``);` `        ``l1.push(``4``);` `        ``l1.push(``5``);` `      `  `        ``/*create a linked list 8->4->2->10 */` `        ``l2.push(``1``);` `        ``l2.push(``3``);` `        ``l2.push(``5``);` `        ``l2.push(``6``);` `        `  `        ``System.out.print(``"First List: \n"``);` `        ``printList(l1.head);` `        ``System.out.println(``"\nSecond List: "``);` `        ``printList(l2.head);` `        `  `        ``printUnionIntersection(l1.head, l2.head);` `        `  `    ``}` `}`   `//Link list node` `class` `Node{` `    ``int` `data;` `    ``Node next;` `    ``Node(``int` `d){` `        ``this``.data=d;` `    ``}` `}`   `//Utility class to create a linked list` `class` `LinkedList{` `    `  `    ``Node head;` `    `  `    ``//A utility function to insert a node at the` `   ``//beginning of a linked list` `    ``void` `push(``int` `new_data){ ` `        `  `        ``//allocate node and put in the data` `        ``Node new_node = ``new` `Node(new_data);` `        `  `        ``//link the old list off the new node` `        ``new_node.next = head;` `        `  `        ``//move the head to point to the new node` `        ``head=new_node;` `    ``}` `    `  `}`   `//This code is contributed by shruti456rawal`

## Python3

 `# Python code for finding union and intersection of linkedList`     `class` `linkedList:` `    ``def` `__init__(``self``):` `        ``self``.head ``=` `None` `        ``self``.tail ``=` `None`   `    ``def` `insert(``self``, data):` `        ``if` `self``.head ``is` `None``:` `            ``self``.head ``=` `Node(data)` `            ``self``.tail ``=` `self``.head` `        ``else``:` `            ``self``.tail.``next` `=` `Node(data)` `            ``self``.tail ``=` `self``.tail.``next`     `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`   `# return the head of new list containing the intersection of 2 linkedList`     `def` `findIntersection(head1, head2):` `    ``# creating a map` `    ``hashmap ``=` `{}`   `    ``# traversing on first list` `    ``while``(head1 !``=` `None``):` `        ``data ``=` `head1.data` `        ``if``(data ``not` `in` `hashmap.keys()):` `            ``hashmap[data] ``=` `1` `        ``head1 ``=` `head1.``next`   `    ``# making a new linkedList` `    ``ans ``=` `linkedList()` `    ``while``(head2 !``=` `None``):` `        ``data ``=` `head2.data` `        ``if``(data ``in` `hashmap.keys()):` `            ``# adding data to new list` `            ``ans.insert(data)` `        ``head2 ``=` `head2.``next` `    ``return` `ans.head`   `# return the head of new list containing the union of 2 linkedList`     `def` `union(head1, head2):` `    ``# creating a map` `    ``hashmap ``=` `{}`   `    ``# traversing on first list` `    ``while``(head1 !``=` `None``):` `        ``data ``=` `head1.data` `        ``if``(data ``not` `in` `hashmap.keys()):` `            ``hashmap[data] ``=` `1` `        ``head1 ``=` `head1.``next`   `    ``while``(head2 !``=` `None``):` `        ``data ``=` `head2.data` `        ``if``(data ``not` `in` `hashmap.keys()):` `            ``hashmap[data] ``=` `1` `        ``head2 ``=` `head2.``next`   `    ``# making a new linkedList` `    ``ans ``=` `linkedList()`   `    ``# traverse on hashmap` `    ``for` `key, value ``in` `hashmap.items():` `        ``ans.insert(key)`   `    ``return` `ans.head`     `def` `printList(head):` `    ``while` `head:` `        ``print``(head.data, end``=``' '``)` `        ``head ``=` `head.``next` `    ``print``()`     `if` `__name__ ``=``=` `'__main__'``:`   `    ``# first list` `    ``ll1 ``=` `linkedList()` `    ``ll1.insert(``1``)` `    ``ll1.insert(``2``)` `    ``ll1.insert(``3``)` `    ``ll1.insert(``4``)` `    ``ll1.insert(``5``)`   `    ``# second list` `    ``ll2 ``=` `linkedList()` `    ``ll2.insert(``1``)` `    ``ll2.insert(``3``)` `    ``ll2.insert(``5``)` `    ``ll2.insert(``6``)`   `    ``print``(``"First list is "``)` `    ``printList(ll1.head)`   `    ``print``(``"Second list is "``)` `    ``printList(ll2.head)`   `    ``print``(``"Intersection list is"``)` `    ``printList(findIntersection(ll1.head, ll2.head))`   `    ``print``(``"Union list is "``)` `    ``printList(union(ll1.head, ll2.head))`     `# This code is contributed by Arpit Jain`

Output:

```First list is
5 4 3 2 1
Second list is
6 5 3 1
Intersection list is
3 5 1
Union list is
3 4 6 5 2 1 ```

We can also handle the case of duplicates by maintaining separate Hash for both the lists. Complexity Analysis:

• Time Complexity: O(m+n). Here ‘m’ and ‘n’ are number of elements present in first and second lists respectively. Reason: For Union: Traverse both the lists, store the elements in Hash-map and update the respective count. For Intersection: Check if count of an element in hash-map is ‘2’.
• Auxiliary Space: O(m+n). Use of Hash-map data structure for storing values.