Java Program To Perform Union of Two Linked Lists Using Priority Queue
Last Updated :
30 May, 2022
Given two linked lists, your task is to complete the function make union(), which returns the union of two linked lists. This union should include all the distinct elements only. The new list formed should be in non-decreasing order.
Input: L1 = 9->6->4->2->3->8
L2 = 1->2->8->6->2
Output: 1 2 3 4 6 8 9
Approach:
There are two types of heap as we all know that is min heap and max heap
- Min heap – Stores all the elements in ascending order
- Max heap – Stores all the elements in descending order
Let us first visualize using min heap in order to interpret program execution how union of two linked list is carried on, so de we are having two operations as listed to visualize:
- Insertion
- Removal
Insertion: After inserting all the distinct elements of two linked lists,
Removal: Removing the root until minheap is empty
Removing the root with value 1:
Removing the root with value 2:
Removing the root with value 3:
Removing the root with value 4:
Removing the root with value 6:
Removing the root with value 8:
Removing the root with value 9:
Hence we can conclude that in the min-heap, the smallest element will be at the root of the heap, and in the max heap, the greatest element will be at the root of the heap. While implementing the remove() function on heap, the root element will be removed. Since the output should be in increasing order, Min heap can be used. Priority Queue is used to implement min heap in java.
Example
Java
import java.io.*;
import java.util.*;
class Node {
int data;
Node next;
Node( int a)
{
data = a;
next = null ;
}
}
public class GfG {
static Scanner sc = new Scanner(System.in);
public static Node inputList1()
{
Node head, tail;
head = tail = new Node( 9 );
tail.next = new Node( 6 );
tail = tail.next;
tail.next = new Node( 4 );
tail = tail.next;
tail.next = new Node( 2 );
tail = tail.next;
tail.next = new Node( 3 );
tail = tail.next;
tail.next = new Node( 8 );
tail = tail.next;
return head;
}
public static Node inputList2()
{
Node head, tail;
head = tail = new Node( 1 );
tail.next = new Node( 2 );
tail = tail.next;
tail.next = new Node( 8 );
tail = tail.next;
tail.next = new Node( 6 );
tail = tail.next;
tail.next = new Node( 2 );
tail = tail.next;
return head;
}
public static void printList(Node n)
{
while (n != null ) {
System.out.print(n.data + " " );
n = n.next;
}
}
public static void main(String args[])
{
Node head1 = inputList1();
Node head2 = inputList2();
Union obj = new Union();
printList(obj.findUnion(head1, head2));
}
}
class Union {
public static Node findUnion(Node head1, Node head2)
{
PriorityQueue<Integer> minheap
= new PriorityQueue<Integer>();
Node l1 = head1, l2 = head2;
while (l1 != null ) {
if (!minheap.contains(l1.data)) {
minheap.add(l1.data);
}
l1 = l1.next;
}
while (l2 != null ) {
if (!minheap.contains(l2.data)) {
minheap.add(l2.data);
}
l2 = l2.next;
}
Node union = new Node( 0 ), start = union;
while (!minheap.isEmpty()) {
Node temp = new Node(minheap.remove());
start.next = temp;
start = start.next;
}
return union.next;
}
}
|
Time complexity: O(nlogn), Space complexity: O(n)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...