# Union and Intersection of two Linked List using Hashing

• Difficulty Level : Basic
• Last Updated : 27 Jan, 2023

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;`   `struct` `Node {` `int` `data;` `struct` `Node* next;` `};`   `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 of the new node */` `new_node->next = (*head_ref);`   `/* move the head to point to the new node */` `(*head_ref) = new_node;` `}`   `struct` `Node* getIntersection(Node *head1,Node *head2)` `{` `   ``unordered_map<``int``, ``bool``> m;` `struct` `Node* result = NULL;`   `   ``Node *p=head1;` `   ``while``(p!=NULL){` `       ``m[p->data]=``true``;` `       ``p=p->next;` `   ``}` `   ``p=head2;` `   ``while``(p!=NULL){` `       ``if``(m[p->data]==``true``){` `           ``push(&result,p->data);` `       ``}` `       ``p=p->next;` `   ``}` `return` `result;` `}`   `struct` `Node *getUnion(Node *head1,Node *head2){` `   ``set<``int``> union_list;` `   ``Node *p=head1;` `   ``while``(p!=NULL){` `       ``union_list.insert(p->data);` `       ``p=p->next;` `   ``}` `   ``p=head2;` `   ``while``(p!=NULL){` `       ``union_list.insert(p->data);` `       ``p=p->next;` `   ``}` `   ``Node *result=NULL;` `   ``for``(``auto` `i:union_list){` `       ``push(&result,i);` `   ``}` `   ``return` `result;` `}` `void` `printList(``struct` `Node* node)` `{` `while` `(node != NULL) {` ` ``printf``(``"%d "``, node->data);` ` ``node = node->next;` `}` `}`   `void` `printUnionIntersection(Node* head1,Node* head2)` `{` `Node* intersection_list = getIntersection(head1,head2);` `Node* union_list = getUnion(head1,head2);`   `printf``(``"\nIntersection list is \n"``);` `printList(intersection_list);` `printf``(``"\nUnion list is \n"``);` `printList(union_list);` `}` `int` `main()` `{` `struct` `Node* head1 = NULL;` `struct` `Node* head2 = NULL;` `//list1` `   ``push(&head1, 1);` `push(&head1, 2);` `push(&head1, 3);` `push(&head1, 3);` `push(&head1, 4);` `push(&head1, 5);`   `//list 2` `push(&head2, 1);` `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 of 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`

## Javascript

 `// JavaScript program to find union and intersection of` `// two unsorted linked lists in O(m+n) time.` `// structure of a node` `class Node{` `    ``constructor(data){` `        ``this``.data = data;` `        ``this``.next = ``null``;` `    ``}` `}`   `function` `push(head_ref, new_data){` `    ``// allocate node and put in data` `    ``let new_node = ``new` `Node(new_data);` `    `  `    ``// link the old list of the new node` `    ``new_node.next = head_ref;` `    `  `    ``// move the head to point to the new node` `    ``head_ref = new_node;` `    ``return` `head_ref;` `}`   `function` `getIntersection(head1, head2){` `    ``let m = ``new` `Map();` `    ``let result = ``null``;` `    `  `    ``let p = head1;` `    ``while``(p != ``null``){` `        ``m.set(p.data, ``true``);` `        ``p = p.next;` `    ``}` `    ``p = head2;` `    ``while``(p != ``null``){` `        ``if``(m.has(p.data) && m.get(p.data) == ``true``){` `            ``result = push(result, p.data);` `        ``}` `        ``p = p.next;` `    ``}` `    ``return` `result;` `}`   `function` `getUnion(head1, head2){` `    ``let union_list = ``new` `Set();` `    ``let p = head1;` `    ``while``(p != ``null``){` `        ``union_list.add(p.data);` `        ``p = p.next;` `    ``}` `    ``p = head2;` `    ``while``(p != ``null``){` `        ``union_list.add(p.data);` `        ``p = p.next;` `    ``}` `    ``let result = ``null``;` `    ``union_list.forEach(``function``(value){` `        ``result = push(result, value);` `    ``})` `    ``return` `result;` `}`   `function` `printList(node){` `    ``while``(node != ``null``){` `        ``document.write(node.data + ``" "``);` `        ``node = node.next;` `    ``}` `}`   `function` `printUnionIntersection(head1, head2){` `    ``let intersection_list = getIntersection(head1,head2);` `    ``let union_list = getUnion(head1,head2);` `    `  `    ``console.log(``"Intersection list is : "``);` `    ``printList(intersection_list);` `    ``console.log(``"Union list is : "``);` `    ``printList(union_list);` `}`   `// driver code to test above funciton` `let head1 = ``null``;` `let head2 = ``null``;`   `// list1` `head1 = push(head1, 1);` `head1 = push(head1, 2);` `head1 = push(head1, 3);` `head1 = push(head1, 3);` `head1 = push(head1, 4);` `head1 = push(head1, 5);`   `// list2` `head2 = push(head2, 1);` `head2 = push(head2, 5);` `head2 = push(head2, 6);`   `console.log(``"First list is : "``);` `printList(head1);`   `console.log(``"Second list is : "``);` `printList(head2);`   `printUnionIntersection(head1, head2);`   `// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)`

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.