Union and Intersection of two Linked Lists

Make union and intersection lists containing the union and intersection of the elements present in the two specified Linked Lists. It is irrelevant how the elements are arranged in output lists.

EXAMPLES

Example-1

List1: 10->15->4->20
List2:  8->4->2->10

Output:

Intersection List: 4->10
Union List: 2->8->20->4->15->10

Method1: Simple

The basic algorithms listed below will produce intersection and union lists, respectively.
Intersection (list1, list2)
Make the result list's initial value NULL. Every entry in list1 is found by traversing list2, and if it appears in list2, it is added to the result.
Union (lists 1, 2, and 3):
Create a new list from scratch, then store the first and second list data to remove any duplicates.
and finally add it to our new list before returning the head of the list.

CODE

// C++ program to find union
// and intersection of two unsorted
// linked lists
#include "bits/stdc++.h"
using namespace std;

/* Link list node */
struct Node {
	int data;
	struct Node* next;
	Node(int x)
	{
		data = x;
		next = NULL;
	}
};

/* A utility function to insert a
node at the beginning ofa linked list*/
void push(struct Node** head_ref, int new_data);

/* A utility function to check if
given data is present in a list */
bool isPresent(struct Node* head, int data);

/* Function to get union of two
linked lists head1 and head2 */
struct Node* getUnion(struct Node* head1,
					struct Node* head2)
{
	struct Node* ans = new Node(-1);
	struct Node* head = ans;
	set<int> st;
	while (head1 != NULL) {
		st.insert(head1->data);
		head1 = head1->next;
	}
	while (head2 != NULL) {
		st.insert(head2->data);
		head2 = head2->next;
	}
	for (auto it : st) {
		struct Node* t = new Node(it);
		ans->next = t;
		ans = ans->next;
	}
	head = head->next;
	return head;
}

/* Function to get intersection of
two linked lists head1 and head2 */
struct Node* getIntersection(struct Node* head1,
							struct Node* head2)
{

	struct Node* result = NULL;
	struct Node* t1 = head1;

	// Traverse list1 and search each element of it in
	// list2. If the element is present in list 2, then
	// insert the element to result
	while (t1 != NULL) {
		if (isPresent(head2, t1->data))
			push(&result, t1->data);
		t1 = t1->next;
	}
	return result;
}
/* 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;
}

/* A utility function to print a linked list*/
void printList(struct Node* node)
{
	while (node != NULL) {
		cout << " " << node->data;
		node = node->next;
	}
}
bool isPresent(struct Node* head, int data)
{
	struct Node* t = head;
	while (t != NULL) {
		if (t->data == data)
			return 1;
		t = t->next;
	}
	return 0;
}

/* Driver program to test above function*/
int main()
{

	/* Start with the empty list */
	struct Node* head1 = NULL;
	struct Node* head2 = NULL;
	struct Node* intersecn = NULL;
	struct Node* unin = NULL;

	/*create a linked lists 10->15->5->20 */
	push(&head1, 20);
	push(&head1, 4);
	push(&head1, 15);
	push(&head1, 10);

	/*create a linked lists 8->4->2->10 */
	push(&head2, 10);
	push(&head2, 2);
	push(&head2, 4);
	push(&head2, 8);
	intersecn = getIntersection(head1, head2);
	unin = getUnion(head1, head2);
	cout << "\n First list is " << endl;
	printList(head1);
	cout << "\n Second list is " << endl;
	printList(head2);
	cout << "\n Intersection list is " << endl;
	printList(intersecn);
	cout << "\n Union list is " << endl;
	printList(unin);
	return 0;
}

Output:

First list is 
10 15 4 20
Second list is 
8 4 2 10
Intersection list is 
4 10
Union list is 
2 8 20 4 15 10

Analysis of Complexity:

Time Complexity:

O(m*n) time complexity.

Here, "m" and "n" refer to the first and second lists' respective total numbers of elements.

For the union, we determine whether each element in list-2 is already present in the resultant list created using list-1.

For intersection, we determine whether each element in list-1 is also present in list-2.

Additional Space: O (1).

No data structure is used to store values.

Method 2: Use Merge Sort

The methods used in this method for intersection and union are fairly similar. We traverse the sorted lists to obtain union and intersection after sorting the provided lists.

The actions to take in order to obtain intersection and union lists are as follows.

Merge sort is used to order the first linked list. It takes this step O(mLogm) time. For information on this phase, see this post.

Merge sort is used to order the second Linked List. It takes this step O(nLogn) time. For information on this phase, see this post.

Using a linear search, find the intersection and union of the two sorted lists. It takes this step O(m + n) time. The same algorithm that is used to sort arrays can be applied to this phase.

This approach's time complexity is O(mLogm + nLogn), which is less time-consuming than method 1's.

Method 3: Hashing

Union (list1, list2)

Make a hash table that is empty and initialise the result list to be NULL. Look at the element in the hash table for each element you visit as you go through both lists one at a time. In the event that the element is missing, add it to the result list. Ignore the element if it is present.

Intersection (list1, list2)

Make a hash table that is empty and initialise the result list to be NULL. List traversal 1. Insert the entry in the hash table for each element in list1 that is being examined. Look up each element in the hash table as you go through list 2, one element at a time. Insert the element into the result list if it is present. Ignore the element if it's not there.

The two techniques mentioned above presuppose that there are no duplicates.

CODE

// Java code for Union and Intersection of two
// Linked Lists
import java.util.HashMap;
import java.util.HashSet;

class LinkedList {
	Node head; // head of list

	/* Linked list Node*/
	class Node {
		int data;
		Node next;
		Node(int d)
		{
			data = d;
			next = null;
		}
	}

	/* Utility function to print list */
	void printList()
	{
		Node temp = head;
		while (temp != null) {
			System.out.print(temp.data + " ");
			temp = temp.next;
		}
		System.out.println();
	}

	/* Inserts a node at start of linked list */
	void push(int new_data)
	{
		/* 1 & 2: Allocate the Node &
		Put in the data*/
		Node new_node = new Node(new_data);

		/* 3. Make next of new Node as head */
		new_node.next = head;

		/* 4. Move the head to point to new Node */
		head = new_node;
	}

	public void append(int new_data)
	{
		if (this.head == null) {
			Node n = new Node(new_data);
			this.head = n;
			return;
		}
		Node n1 = this.head;
		Node n2 = new Node(new_data);
		while (n1.next != null) {
			n1 = n1.next;
		}

		n1.next = n2;
		n2.next = null;
	}

	/* A utility function that returns true if data is
	present in linked list else return false */
	boolean isPresent(Node head, int data)
	{
		Node t = head;
		while (t != null) {
			if (t.data == data)
				return true;
			t = t.next;
		}
		return false;
	}

	LinkedList getIntersection(Node head1, Node head2)
	{
		HashSet<Integer> hset = new HashSet<>();
		Node n1 = head1;
		Node n2 = head2;
		LinkedList result = new LinkedList();

		// loop stores all the elements of list1 in hset
		while (n1 != null) {
			if (hset.contains(n1.data)) {
				hset.add(n1.data);
			}
			else {
				hset.add(n1.data);
			}
			n1 = n1.next;
		}

		// For every element of list2 present in hset
		// loop inserts the element into the result
		while (n2 != null) {
			if (hset.contains(n2.data)) {
				result.push(n2.data);
			}
			n2 = n2.next;
		}
		return result;
	}

	LinkedList getUnion(Node head1, Node head2)
	{
		// HashMap that will store the
		// elements of the lists with their counts
		HashMap<Integer, Integer> hmap = new HashMap<>();
		Node n1 = head1;
		Node n2 = head2;
		LinkedList result = new LinkedList();

		// loop inserts the elements and the count of
		// that element of list1 into the hmap
		while (n1 != null) {
			if (hmap.containsKey(n1.data)) {
				int val = hmap.get(n1.data);
				hmap.put(n1.data, val + 1);
			}
			else {
				hmap.put(n1.data, 1);
			}
			n1 = n1.next;
		}

		// loop further adds the elements of list2 with
		// their counts into the hmap
		while (n2 != null) {
			if (hmap.containsKey(n2.data)) {
				int val = hmap.get(n2.data);
				hmap.put(n2.data, val + 1);
			}
			else {
				hmap.put(n2.data, 1);
			}
			n2 = n2.next;
		}

		// Eventually add all the elements
		// into the result that are present in the hmap
		for (int a : hmap.keySet()) {
			result.append(a);
		}
		return result;
	}

	/* Driver program to test above functions */
	public static void main(String args[])
	{
		LinkedList llist1 = new LinkedList();
		LinkedList llist2 = new LinkedList();
		LinkedList union = new LinkedList();
		LinkedList intersection = new LinkedList();

		/*create a linked list 10->15->4->20 */
		llist1.push(20);
		llist1.push(4);
		llist1.push(15);
		llist1.push(10);

		/*create a linked list 8->4->2->10 */
		llist2.push(10);
		llist2.push(2);
		llist2.push(4);
		llist2.push(8);

		intersection
			= intersection.getIntersection(llist1.head,
										llist2.head);
		union = union.getUnion(llist1.head, llist2.head);

		System.out.println("First List is");
		llist1.printList();

		System.out.println("Second List is");
		llist2.printList();

		System.out.println("Intersection List is");
		intersection.printList();

		System.out.println("Union List is");
		union.printList();
	}
}

Output:

First List is
10 15 4 20 
Second List is
8 4 2 10 
Intersection List is
10 4 
Union List is
2 4 20 8 10 15

Analysis of Complexity:

Time Complexity:

O(m+n) time complexity.

Here, "m" and "n" refer to the first and second lists' respective total numbers of elements.

Union requires traversing both lists, storing the elements in hash maps, and updating each count.

For a crossroads: List-1 should be traversed, its elements should be stored in a hash map, and then each element in list-2 should be checked to see if it already exists in the map. There is an O(1) time delay.

For intersection, we determine whether each element in list-1 is also present in list-2.

Additional Space: O (m+n).

Hash-map data structures are used to store values.

Next TopicKth Largest element in an array

← prev next →