Two Sorted LinkedList Intersection in Java

In this problem, two sorted linked list (in non-decreasing order) is given. The task is to find the intersection of those two linked lists, i.e., finding those elements that are present in both of the linked lists.

Example 1:

Input:

Linked List 1: 12 -> 13 -> 35 -> 40 -> 56 -> 89 -> 90 -> 92

Linked List 2: 9 -> 14 -> 15 -> 30 -> 40 -> 85 -> 90 -> 92

Output:

40 -> 90 -> 92
The elements 40, 90 and 92 are the elements that are common in both the linked list 1 and linked list 2.

Let's see various approaches to solve this problem.

Using Dummy Node

The approach is to use a dummy or temporary node at the beginning of the output list. The tail pointer is a pointer that is pointing to the last node of the output list so that the new nodes can be added or appended quickly. The temporary node gives the tail a space of memory to point to. Note that in the beginning, the tail pointer points to the output dummy node. Now the task is to iterate over the given linked list using a single loop. Note that the loop will terminate if any of the linked lists is traversed completely. In the loop, two-pointer approach is used. One pointer ptr1 for the linked list 1 and ptr2 for the linked list 2. There are the following three cases:

Case 1: Value pointed by ptr1 is greater than value pointed by ptr2.

Case 2: Value pointer by ptr1 is less than the value pointer by ptr2.

Case 3: Value pointed by ptr1 and ptr2 is equal.

For case 1, increment ptr2 to point to the next node. For case 2, increment ptr1 to point to the next node. For case 3, print the value and increment, both the pointers to point to the next node. In case 3, we have to take care of the nodes that contain the same value in the linked list. For example,

Linked list 1: 4 -> 4 -> 4 -> 4 -> 4 -> 4 -> 5

Linked list 2: 4 -> 4 -> 4-> 5

Here, case 3 applies, as the first node of both the linked list is 4. So, we print the value 4, and increment ptr1 and ptr2 to point to the next node. However, even after incrementing ptr1 and ptr2 both points to the same value 4. Therefore, we again have to increment both the pointers; but this time we will not print the value 4 as 4 is already printed, and we will keep on incrementing the pointers such that both the pointers point to the value 5.

Hence, the output is 4 and 5. Note that intersection here is working in the same way we learnt in the intersection in the chapter called sets.

Observe the following program.

FileName: LinkedListIntersection.java

public class LinkedListIntersection
{

// head nodes for pointing to 1st and 2nd linked lists
static LinkedLstNode p1 = null;
static LinkedLstNode p2 = null;

// a dummy or temp node for storing the intersection
static LinkedLstNode dmy = null;

// a tail node for tracking the last node of the linked
// list such that insertion of new nodes gets easy
static LinkedLstNode tl = null;

// static class LinkedLstNode
static class LinkedLstNode 
{
int val;
LinkedLstNode next;

// constructor of the class
LinkedLstNode(int v) 
{
this.val = v;
next = null;
}
}

// method for displaying the list
void displayList(LinkedLstNode st) 
{
LinkedLstNode ptr = st;
while (ptr != null) 
{
System.out.print(ptr.val + " ");
ptr = ptr.next;
}
System.out.println();
}

// elements insertion in the list
void push(int v) 
{
LinkedLstNode t = new LinkedLstNode(v);
if(dmy == null) 
{
dmy = t;
tl = t;
}
else 
{
tl.next = t;
tl = t;
}
}

// method for looking for the intersection and inserting it to the dummy list
void intersectEle()
{

// pointers for iteration
LinkedLstNode ptr1 = p1;
LinkedLstNode ptr2 = p2;
int tempVal = -1;
while(ptr1 != null && ptr2 != null)
{   
if(ptr1.val == ptr2.val)
{
if(tempVal != ptr1.val)
{
// adding to the dummy list
push(ptr1.val);
tempVal = ptr1.val;
}

ptr1 = ptr1.next;
ptr2 = ptr2.next;
}
else if(ptr1.val < ptr2.val)
{
ptr1 = ptr1.next;
}
else
ptr2 = ptr2.next;
}
}

// Driver code
public static void main(String args[])
{
// creating an object of the class LinkedListIntersection
LinkedListIntersection ll = new LinkedListIntersection();

// the first linked list
ll.p1 = new LinkedLstNode(12);
ll.p1.next = new LinkedLstNode(13);
ll.p1.next.next = new LinkedLstNode(35);
ll.p1.next.next.next = new LinkedLstNode(40);
ll.p1.next.next.next.next = new LinkedLstNode(56);
ll.p1.next.next.next.next.next = new LinkedLstNode(89);
ll.p1.next.next.next.next.next.next = new LinkedLstNode(90);
ll.p1.next.next.next.next.next.next.next = new LinkedLstNode(92);

// the second linked list
ll.p2 = new LinkedLstNode(9);
ll.p2.next = new LinkedLstNode(14);
ll.p2.next.next = new LinkedLstNode(15);
ll.p2.next.next.next = new LinkedLstNode(30);
ll.p2.next.next.next.next = new LinkedLstNode(40);
ll.p2.next.next.next.next.next = new LinkedLstNode(85);
ll.p2.next.next.next.next.next.next = new LinkedLstNode(90);
ll.p2.next.next.next.next.next.next.next = new LinkedLstNode(92);

// invoking method for call for intersection
ll.intersectEle();

// displaying the first linked list
System.out.println("The first linked list is: ");
ll.displayList(p1);

System.out.println();

// displaying the second linked list
System.out.println("The second linked list is: ");
ll.displayList(p2);

System.out.println();

// displaying the required intersection
System.out.println("The common elements of the first & the second linked list are: ");
ll.displayList(dmy);

ll.p1 = null;
ll.p2 = null;
ll.dmy = null;

ll.p1 = new LinkedLstNode(4);
ll.p1.next = new LinkedLstNode(4);
ll.p1.next.next = new LinkedLstNode(4);
ll.p1.next.next.next = new LinkedLstNode(4);
ll.p1.next.next.next.next = new LinkedLstNode(4);
ll.p1.next.next.next.next.next = new LinkedLstNode(5);

ll.p2 = new LinkedLstNode(4);
ll.p2.next = new LinkedLstNode(4);
ll.p2.next.next = new LinkedLstNode(4);
ll.p2.next.next.next = new LinkedLstNode(5);


System.out.println("\n \n");

// invoking method for call for intersection
ll.intersectEle();

// displaying the first linked list
System.out.println("The first linked list is: ");
ll.displayList(p1);

System.out.println();

// displaying the second linked list
System.out.println("The second linked list is: ");
ll.displayList(p2);

System.out.println();

// displaying the required intersection
System.out.println("The common elements of the first & the second linked list are: ");
ll.displayList(dmy);

}
}

Output:

The first linked list is: 
12 13 35 40 56 89 90 92 

The second linked list is: 
9 14 15 30 40 85 90 92 

The common elements of the first & the second linked list are: 
40 90 92 

 

The first linked list is: 
4 4 4 4 4 5 

The second linked list is: 
4 4 4 5 

The common elements of the first & the second linked list are: 
4 5

Time Complexity: The time complexity of the above program is O(min(a, b)), where a and b are the numbers of elements or nodes present in the linked list 1 and 2, respectively.

Using Recursion

Using recursion also, we can achieve the same thing.

FileName: LinkedListIntersection1.java

public class LinkedListIntersection1
{

// head nodes for pointing to 1st and 2nd linked lists
static LinkedLstNode p1 = null;
static LinkedLstNode p2 = null;
static LinkedLstNode head = null;
static LinkedLstNode tail = null;

// a dummy or temp node for storing the intersection
static LinkedLstNode dmy = null;

// static class LinkedLstNode
static class LinkedLstNode 
{
int val;
LinkedLstNode next;

// constructor of the class
LinkedLstNode(int v) 
{
this.val = v;
next = null;
}
}

// method for displaying the list
void displayList(LinkedLstNode st) 
{
LinkedLstNode ptr = st;
while (ptr != null) 
{
System.out.print(ptr.val + " ");
ptr = ptr.next;
}
System.out.println();
}
// method for looking for the intersection and inserting it to the dummy list
public void intersectEle(LinkedLstNode ptr1, LinkedLstNode ptr2)
{
// handling base case
if (ptr1 == null || ptr2 == null)
{
return;
}
// If both the lists are not empty 

// advancing in the list ptr1
if (ptr1.val < ptr2.val)
{
intersectEle(ptr1.next, ptr2);
}

// advancing in the list ptr2
else if (ptr1.val > ptr2.val)
{
intersectEle(ptr1, ptr2.next);
}
else 
{
// the following statements come into action
// only when ptr1.val == ptr2.val
LinkedLstNode temp = new LinkedLstNode(ptr1.val);


// Advancing both the lists using recursion
if(head == null)
{
head = temp;
tail = temp;
}

// removing the duplicates
else if(tail.val != temp.val)
{
tail.next = temp;
tail = tail.next;
}

intersectEle(ptr1.next, ptr2.next);
}
}

// Driver code
public static void main(String args[])
{
// creating an object of the class LinkedListIntersection1
LinkedListIntersection1 ll = new LinkedListIntersection1();

// the first linked list
ll.p1 = new LinkedLstNode(12);
ll.p1.next = new LinkedLstNode(13);
ll.p1.next.next = new LinkedLstNode(35);
ll.p1.next.next.next = new LinkedLstNode(40);
ll.p1.next.next.next.next = new LinkedLstNode(56);
ll.p1.next.next.next.next.next = new LinkedLstNode(89);
ll.p1.next.next.next.next.next.next = new LinkedLstNode(90);
ll.p1.next.next.next.next.next.next.next = new LinkedLstNode(92);

// the second linked list
ll.p2 = new LinkedLstNode(9);
ll.p2.next = new LinkedLstNode(14);
ll.p2.next.next = new LinkedLstNode(15);
ll.p2.next.next.next = new LinkedLstNode(30);
ll.p2.next.next.next.next = new LinkedLstNode(40);
ll.p2.next.next.next.next.next = new LinkedLstNode(85);
ll.p2.next.next.next.next.next.next = new LinkedLstNode(90);
ll.p2.next.next.next.next.next.next.next = new LinkedLstNode(92);

// invoking method for call for intersection
ll.intersectEle(ll.p1, ll.p2);

// displaying the first linked list
System.out.println("The first linked list is: ");
ll.displayList(p1);

System.out.println();

// displaying the second linked list
System.out.println("The second linked list is: ");
ll.displayList(p2);

System.out.println();

// displaying the required intersection
System.out.println("The common elements of the first & the second linked list are: ");
ll.displayList(ll.head);

ll.p1 = null;
ll.p2 = null;
ll.head = null;
ll.tail = null;

ll.p1 = new LinkedLstNode(4);
ll.p1.next = new LinkedLstNode(4);
ll.p1.next.next = new LinkedLstNode(4);
ll.p1.next.next.next = new LinkedLstNode(4);
ll.p1.next.next.next.next = new LinkedLstNode(4);
ll.p1.next.next.next.next.next = new LinkedLstNode(5);

ll.p2 = new LinkedLstNode(4);
ll.p2.next = new LinkedLstNode(4);
ll.p2.next.next = new LinkedLstNode(4);
ll.p2.next.next.next = new LinkedLstNode(5);


System.out.println("\n \n");

// invoking method for call for intersection
ll.intersectEle(ll.p1, ll.p2);

// displaying the first linked list
System.out.println("The first linked list is: ");
ll.displayList(p1);

System.out.println();

// displaying the second linked list
System.out.println("The second linked list is: ");
ll.displayList(p2);

System.out.println();

// displaying the required intersection
System.out.println("The common elements of the first & the second linked list are: ");
ll.displayList(ll.head);


}
}

Output:

The first linked list is: 
12 13 35 40 56 89 90 92 

The second linked list is: 
9 14 15 30 40 85 90 92 

The common elements of the first & the second linked list are: 
40 90 92

Using Hashing

As we know that HashSet in Java contains only unique elements; hence, we can use this property to find the common elements from the given two linked lists. Observe the following program.

FileName: LinkedListIntersection2.java

import java.util.*;

public class LinkedListIntersection2 
{
static LinkedLstNode p1 = null;
static LinkedLstNode p2 = null;

// static class LinkedLstNode
static class LinkedLstNode 
{
int val;
LinkedLstNode next;

// constructor of the class
LinkedLstNode(int v) 
{
this.val = v;
next = null;
}
}

// method for displaying the array list
public void displayList(ArrayList<Integer> aList) 
{
int size = aList.size();
for(int i = 0; i < size; i++)
{
System.out.print(aList.get(i) + " ");
}
}

// method for displaying the linked list
void displayLinkedList(LinkedLstNode st) 
{
LinkedLstNode ptr = st;
while (ptr != null) 
{
System.out.print(ptr.val + " ");
ptr = ptr.next;
}
System.out.println();
}

		
// a method for finding the common elements
public ArrayList<Integer> intersectionList(LinkedLstNode t1, LinkedLstNode t2) 
{
// common elements will be stored in this array list
ArrayList<Integer> temp = new ArrayList<Integer>();

// two hash sets for two different linked list
HashSet<Integer> set1 = new HashSet<Integer>();
HashSet<Integer> set2 = new HashSet<Integer>();

// for stroring the unique 
// elements of the linked list t1
while(t1 != null) 
{

set1.add(t1.val);
t1 = t1.next;
}


// for stroring the unique 
// elements of the linked list t2
while(t2 != null) 
{
set2.add(t2.val);
t2 = t2.next;

}

// iterating over each element 
// present in the set 1
for (Integer i : set1) 
{
if(set2.contains(i))
{
    // reaching here means
    // integer i is present in
    // both the sets and therefore
    // we can add it in the array list
    temp.add(i);
}
    
}

return temp;

}
	
	
public static void main(String[] args) 
{
// creating an object of the class LinkedListIntersection2
LinkedListIntersection2 ll = new LinkedListIntersection2();

// the first linked list
ll.p1 = new LinkedLstNode(12);
ll.p1.next = new LinkedLstNode(13);
ll.p1.next.next = new LinkedLstNode(35);
ll.p1.next.next.next = new LinkedLstNode(40);
ll.p1.next.next.next.next = new LinkedLstNode(56);
ll.p1.next.next.next.next.next = new LinkedLstNode(89);
ll.p1.next.next.next.next.next.next = new LinkedLstNode(90);
ll.p1.next.next.next.next.next.next.next = new LinkedLstNode(92);

// the second linked list
ll.p2 = new LinkedLstNode(9);
ll.p2.next = new LinkedLstNode(14);
ll.p2.next.next = new LinkedLstNode(15);
ll.p2.next.next.next = new LinkedLstNode(30);
ll.p2.next.next.next.next = new LinkedLstNode(40);
ll.p2.next.next.next.next.next = new LinkedLstNode(85);
ll.p2.next.next.next.next.next.next = new LinkedLstNode(90);
ll.p2.next.next.next.next.next.next.next = new LinkedLstNode(92);

// displaying the first linked list
System.out.println("The first linked list is: ");
ll.displayLinkedList(p1);

System.out.println();

// displaying the second linked list
System.out.println("The second linked list is: ");
ll.displayLinkedList(p2);

System.out.println();

ArrayList<Integer> al = ll.intersectionList(ll.p1, ll.p2);

System.out.println("The common elements of the first & the second linked list are: ");
ll.displayList(al);

ll.p1 = null;
ll.p2 = null;

ll.p1 = new LinkedLstNode(4);
ll.p1.next = new LinkedLstNode(4);
ll.p1.next.next = new LinkedLstNode(4);
ll.p1.next.next.next = new LinkedLstNode(4);
ll.p1.next.next.next.next = new LinkedLstNode(4);
ll.p1.next.next.next.next.next = new LinkedLstNode(5);

ll.p2 = new LinkedLstNode(4);
ll.p2.next = new LinkedLstNode(4);
ll.p2.next.next = new LinkedLstNode(4);
ll.p2.next.next.next = new LinkedLstNode(5);


System.out.println("\n \n");

al = ll.intersectionList(ll.p1, ll.p2);

// displaying the first linked list
System.out.println("The first linked list is: ");
ll.displayLinkedList(p1);

System.out.println();

// displaying the second linked list
System.out.println("The second linked list is: ");
ll.displayLinkedList(p2);

System.out.println();

System.out.println("The common elements of the first & the second linked list are: ");
ll.displayList(al);

}

}

Output:

The first linked list is: 
12 13 35 40 56 89 90 92 

The second linked list is: 
9 14 15 30 40 85 90 92 

The common elements of the first & the second linked list are: 
40 90 92

Time Complexity: As we are traversing both linked lists separately, therefore, the time complexity of the above program is O(a + b), where a and b are the total number of nodes present in the given linked lists.

Next TopicSet Matrix Zeros in Java

← prev next →