Find a triplet from three linked lists with sum equal to a given number
Last Updated :
28 Feb, 2023
Given three linked lists, say a, b and c, find one node from each list such that the sum of the values of the nodes is equal to a given number.
For example, if the three linked lists are 12->6->29, 23->5->8, and 90->20->59, and the given number is 101, the output should be triple “6 5 90”.
In the following solutions, size of all three linked lists is assumed same for simplicity of analysis. The following solutions work for linked lists of different sizes also.
A simple method to solve this problem is to run three nested loops. The outermost loop picks an element from list a, the middle loop picks an element from b and the innermost loop picks from c. The innermost loop also checks whether the sum of values of current nodes of a, b and c is equal to given number. The time complexity of this method will be O(n^3).
Sorting can be used to reduce the time complexity to O(n*n). Following are the detailed steps.
1) Sort list b in ascending order, and list c in descending order.
2) After the b and c are sorted, one by one pick an element from list a and find the pair by traversing both b and c. See isSumSorted() in the following code. The idea is similar to Quadratic algorithm of 3 sum problem.
Following code implements step 2 only. The solution can be easily modified for unsorted lists by adding the merge sort code discussed here.
C++
#include <bits/stdc++.h>
using namespace std;
class Node
{
public :
int data;
Node* next;
};
void push (Node** head_ref, int new_data)
{
Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
bool isSumSorted(Node *headA, Node *headB,
Node *headC, int givenNumber)
{
Node *a = headA;
while (a != NULL)
{
Node *b = headB;
Node *c = headC;
while (b != NULL && c != NULL)
{
int sum = a->data + b->data + c->data;
if (sum == givenNumber)
{
cout << "Triplet Found: " << a->data << " " <<
b->data << " " << c->data;
return true ;
}
else if (sum < givenNumber)
b = b->next;
else
c = c->next;
}
a = a->next;
}
cout << "No such triplet" ;
return false ;
}
int main()
{
Node* headA = NULL;
Node* headB = NULL;
Node* headC = NULL;
push (&headA, 20);
push (&headA, 4);
push (&headA, 15);
push (&headA, 10);
push (&headB, 10);
push (&headB, 9);
push (&headB, 4);
push (&headB, 2);
push (&headC, 1);
push (&headC, 2);
push (&headC, 4);
push (&headC, 8);
int givenNumber = 25;
isSumSorted (headA, headB, headC, givenNumber);
return 0;
}
|
C
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
struct Node
{
int data;
struct Node* next;
};
void push ( struct Node** head_ref, int new_data)
{
struct Node* new_node =
( struct Node*) malloc ( sizeof ( struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
bool isSumSorted( struct Node *headA, struct Node *headB,
struct Node *headC, int givenNumber)
{
struct Node *a = headA;
while (a != NULL)
{
struct Node *b = headB;
struct Node *c = headC;
while (b != NULL && c != NULL)
{
int sum = a->data + b->data + c->data;
if (sum == givenNumber)
{
printf ( "Triplet Found: %d %d %d " , a->data,
b->data, c->data);
return true ;
}
else if (sum < givenNumber)
b = b->next;
else
c = c->next;
}
a = a->next;
}
printf ( "No such triplet" );
return false ;
}
int main()
{
struct Node* headA = NULL;
struct Node* headB = NULL;
struct Node* headC = NULL;
push (&headA, 20);
push (&headA, 4);
push (&headA, 15);
push (&headA, 10);
push (&headB, 10);
push (&headB, 9);
push (&headB, 4);
push (&headB, 2);
push (&headC, 1);
push (&headC, 2);
push (&headC, 4);
push (&headC, 8);
int givenNumber = 25;
isSumSorted (headA, headB, headC, givenNumber);
return 0;
}
|
Java
class LinkedList
{
Node head;
class Node
{
int data;
Node next;
Node( int d) {data = d; next = null ; }
}
boolean isSumSorted(LinkedList la, LinkedList lb, LinkedList lc,
int givenNumber)
{
Node a = la.head;
while (a != null )
{
Node b = lb.head;
Node c = lc.head;
while (b != null && c!= null )
{
int sum = a.data + b.data + c.data;
if (sum == givenNumber)
{
System.out.println( "Triplet found " + a.data +
" " + b.data + " " + c.data);
return true ;
}
else if (sum < givenNumber)
b = b.next;
else
c = c.next;
}
a = a.next;
}
System.out.println( "No Triplet found" );
return false ;
}
void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public static void main(String args[])
{
LinkedList llist1 = new LinkedList();
LinkedList llist2 = new LinkedList();
LinkedList llist3 = new LinkedList();
llist1.push( 20 );
llist1.push( 5 );
llist1.push( 15 );
llist1.push( 100 );
llist2.push( 10 );
llist2.push( 9 );
llist2.push( 4 );
llist2.push( 2 );
llist3.push( 1 );
llist3.push( 2 );
llist3.push( 4 );
llist3.push( 8 );
int givenNumber = 25 ;
llist1.isSumSorted(llist1,llist2,llist3,givenNumber);
}
}
|
Python
class Node:
def __init__( self , new_data):
self .data = new_data
self . next = None
def push ( head_ref, new_data) :
new_node = Node( 0 )
new_node.data = new_data
new_node. next = (head_ref)
(head_ref) = new_node
return head_ref;
def isSumSorted(headA, headB,headC, givenNumber) :
a = headA
while (a ! = None ) :
b = headB
c = headC
while (b ! = None and c ! = None ) :
sum = a.data + b.data + c.data
if ( sum = = givenNumber) :
print "Triplet Found: " , a.data , " " , b.data , " " , c.data,
return True
elif ( sum < givenNumber):
b = b. next
else :
c = c. next
a = a. next
print ( "No such triplet" )
return False
headA = None
headB = None
headC = None
headA = push (headA, 20 )
headA = push (headA, 4 )
headA = push (headA, 15 )
headA = push (headA, 10 )
headB = push (headB, 10 )
headB = push (headB, 9 )
headB = push (headB, 4 )
headB = push (headB, 2 )
headC = push (headC, 1 )
headC = push (headC, 2 )
headC = push (headC, 4 )
headC = push (headC, 8 )
givenNumber = 25
isSumSorted (headA, headB, headC, givenNumber)
|
C#
using System;
public class LinkedList
{
public Node head;
public class Node
{
public int data;
public Node next;
public Node( int d)
{
data = d; next = null ;
}
}
bool isSumSorted(LinkedList la, LinkedList lb,
LinkedList lc, int givenNumber)
{
Node a = la.head;
while (a != null )
{
Node b = lb.head;
Node c = lc.head;
while (b != null && c!= null )
{
int sum = a.data + b.data + c.data;
if (sum == givenNumber)
{
Console.WriteLine( "Triplet found " + a.data +
" " + b.data + " " + c.data);
return true ;
}
else if (sum < givenNumber)
b = b.next;
else
c = c.next;
}
a = a.next;
}
Console.WriteLine( "No Triplet found" );
return false ;
}
void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public static void Main(String []args)
{
LinkedList llist1 = new LinkedList();
LinkedList llist2 = new LinkedList();
LinkedList llist3 = new LinkedList();
llist1.push(20);
llist1.push(5);
llist1.push(15);
llist1.push(100);
llist2.push(10);
llist2.push(9);
llist2.push(4);
llist2.push(2);
llist3.push(1);
llist3.push(2);
llist3.push(4);
llist3.push(8);
int givenNumber = 25;
llist1.isSumSorted(llist1,llist2,llist3,givenNumber);
}
}
|
Javascript
<script>
class Node
{
constructor(d)
{
this .data = d;
this .next = null ;
}
}
function isSumSorted(la,lb,lc,givenNumber)
{
let a = la;
while (a != null )
{
let b = lb;
let c = lc;
while (b != null && c!= null )
{
let sum = a.data + b.data + c.data;
if (sum == givenNumber)
{
document.write( "Triplet found " + a.data +
" " + b.data + " " + c.data+ "<br>" );
return true ;
}
else if (sum < givenNumber)
b = b.next;
else
c = c.next;
}
a = a.next;
}
document.write( "No Triplet found<br>" );
return false ;
}
function push(head_ref,new_data)
{
let new_node = new Node(new_data);
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
let headA = null ;
headA = push (headA, 20)
headA = push (headA, 4)
headA = push (headA, 15)
headA = push (headA, 10)
let headB = null ;
headB = push (headB, 10)
headB = push (headB, 9)
headB = push (headB, 4)
headB = push (headB, 2)
let headC = null ;
headC = push (headC, 1)
headC = push (headC, 2)
headC = push (headC, 4)
headC = push (headC, 8)
let givenNumber = 25
isSumSorted (headA, headB, headC, givenNumber)
</script>
|
Output:
Triplet Found: 15 2 8
Time complexity: O(n2)
The linked lists b and c can be sorted in O(nLogn) time using Merge Sort (See this). The step 2 takes O(n*n) time. So the overall time complexity is O(nlogn) + O(nlogn) + O(n*n) = O(n*n).
In this approach, the linked lists b and c are sorted first, so their original order will be lost. If we want to retain the original order of b and c, we can create copy of b and c.
Auxiliary Space: O(1)
Here constant extra space is used, but if we wish to maintain the original order of lists b and c our time complexity will become O(n) as extra space will be used to store the sorted list elements.
This article is compiled by Abhinav Priyadarshi and reviewed by GeeksforGeeks team.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...