# Program For Finding A Triplet From Three Linked Lists With Sum Equal To A Given Number

Last Updated : 18 Jan, 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 ` `using` `namespace` `std;`   `// CPP program to find a triplet  from three linked lists` `// with sum equal to a given number`   `/* Linked list Node*/` `class` `Node {` `  ``public``:` `  ``int` `data;` `  ``Node* next;` `  ``Node(``int` `d)` `  ``{` `    ``this``->data = d;` `    ``this``->next = NULL;` `  ``}` `};`   `Node* head; ``// head of list`   `/* A function to check if there  are three elements in` ` ``* a, b and c whose sum is equal to  givenNumber. The` ` ``* function assumes that the list b is sorted in` ` ``* ascending order and c is sorted in descending order.` ` ``*/`   `bool` `isSumSorted(Node*& la, Node* lb, Node* lc,` `                 ``int` `givenNumber)` `{` `  ``Node* a = la;`   `  ``// Traverse all nodes of la` `  ``while` `(a != NULL) {` `    ``Node* b = lb;` `    ``Node* c = lc;`   `    ``// for every node in la pick` `    ``// 2 nodes from lb and lc` `    ``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 << endl;` `        ``return` `true``;` `      ``}`   `      ``// If sum is smaller then` `      ``// look for greater value of b` `      ``else` `if` `(sum < givenNumber) {` `        ``b = b->next;` `      ``}` `      ``else` `{` `        ``c = c->next;` `      ``}` `    ``}` `    ``a = a->next;` `  ``}` `  ``cout << ``"No Triplet found"` `<< endl;` `  ``return` `false``;` `}`   `/* Given a reference (pointer to pointer) to the head` `of a list and an int, push a new node on the front` `of the list. */` `void` `push(Node*& list, ``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 = list;`   `  ``/* 4. Move the head to point to new Node */` `  ``list = new_node;` `}`   `int` `main()` `{`   `  ``Node* list1 = ``new` `Node(20);` `  ``Node* list2 = ``new` `Node(10);` `  ``Node* list3 = ``new` `Node(1);`   `  ``/* Create Linked List llist1 100->15->5->20 */` `  ``// list1.push(20);` `  ``push(list1, 5);` `  ``push(list1, 15);` `  ``push(list1, 100);`   `  ``/*create a sorted linked list 'b' 2->4->9->10 */` `  ``// list2.push(10);` `  ``push(list2, 9);` `  ``push(list2, 4);` `  ``push(list2, 2);`   `  ``/*create another sorted linked list 'c' 8->4->2->1` `     ``*/` `  ``// list3.push(1);` `  ``push(list3, 2);` `  ``push(list3, 4);` `  ``push(list3, 8);`   `  ``int` `givenNumber = 25;` `  ``isSumSorted(list1, list2, list3, givenNumber);` `  ``return` `0;` `}`   `// This code is contributed by akashish__`

## Java

 `// Java program to find a triplet  from three linked lists` `// with sum equal to a given number` `public` `class` `LinkedList {`   `    ``/* Linked list Node*/` `    ``public` `class` `Node {` `        ``int` `data;` `        ``Node next;` `        ``public` `Node(``int` `d)` `        ``{` `            ``this``.data = d;` `            ``next = ``null``;` `        ``}` `    ``}`   `    ``public` `Node head; ``// head of list`   `    ``/* A function to check if there  are three elements in` `     ``* a, b and c whose sum is equal to  givenNumber. The` `     ``* function assumes that the list b is sorted in` `     ``* ascending order and c is sorted in descending order.` `     ``*/` `    ``public` `boolean` `isSumSorted(LinkedList la, LinkedList lb,` `                               ``LinkedList lc,` `                               ``int` `givenNumber)` `    ``{` `        ``Node a = la.head;`   `        ``// Traverse all nodes of la` `        ``while` `(a != ``null``) {` `            ``Node b = lb.head;` `            ``Node c = lc.head;`   `            ``// for every node in la pick` `            ``// 2 nodes from lb and lc` `            ``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``;` `                ``}`   `                ``// If sum is smaller then` `                ``// look for greater value of b` `                ``else` `if` `(sum < givenNumber) {` `                    ``b = b.next;` `                ``}` `                ``else` `{` `                    ``c = c.next;` `                ``}` `            ``}` `            ``a = a.next;` `        ``}` `        ``System.out.println(``"No Triplet found"``);` `        ``return` `false``;` `    ``}`   `    ``/* Given a reference (pointer to pointer) to the head` `of a list and an int, push a new node on the front` `of the list. */` `    ``public` `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` `static` `void` `main(String[] args)` `    ``{`   `        ``LinkedList list1 = ``new` `LinkedList();` `        ``LinkedList list2 = ``new` `LinkedList();` `        ``LinkedList list3 = ``new` `LinkedList();`   `        ``/* Create Linked List llist1 100->15->5->20 */` `        ``list1.push(``20``);` `        ``list1.push(``5``);` `        ``list1.push(``15``);` `        ``list1.push(``100``);`   `        ``/*create a sorted linked list 'b' 2->4->9->10 */` `        ``list2.push(``10``);` `        ``list2.push(``9``);` `        ``list2.push(``4``);` `        ``list2.push(``2``);`   `        ``/*create another sorted linked list 'c' 8->4->2->1` `         ``*/` `        ``list3.push(``1``);` `        ``list3.push(``2``);` `        ``list3.push(``4``);` `        ``list3.push(``8``);`   `        ``int` `givenNumber = ``25``;` `        ``list1.isSumSorted(list1, list2, list3, givenNumber);` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## Python3

 `# Python program to find a triplet ` `# from three linked lists with` `# sum equal to a given number`   `# Node class` `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`   `# Linked List class` `class` `LinkedList:` `    ``def` `__init__(``self``):` `        ``self``.head ``=` `None`   `    ``# function to add new node at the beginning` `    ``def` `push(``self``, new_data):` `        ``new_node ``=` `Node(new_data)` `        ``new_node.``next` `=` `self``.head` `        ``self``.head ``=` `new_node`   `    ``# A function to check if there ` `    ``# are three elements in a, b` `    ``# and c whose sum is equal to ` `    ``# givenNumber. The function` `    ``# assumes that the list b is ` `    ``# sorted in ascending order and` `    ``# c is sorted in descending order.` `    ``def` `isSumSorted(``self``, la, lb, lc, givenNumber):` `        ``a ``=` `la.head`   `        ``# Traverse all nodes of la` `        ``while` `a ``is` `not` `None``:` `            ``b ``=` `lb.head` `            ``c ``=` `lc.head`   `            ``# for every node in la pick ` `            ``# 2 nodes from lb and lc` `            ``while` `b ``is` `not` `None` `and` `c ``is` `not` `None``:` `                ``sum` `=` `a.data ``+` `b.data ``+` `c.data` `                ``if` `sum` `=``=` `givenNumber:` `                    ``print``(``"Triplet found"``, a.data, b.data, c.data)` `                    ``return` `True`   `                ``# If sum is smaller then ` `                ``# look for greater value of b` `                ``elif` `sum` `< givenNumber:` `                    ``b ``=` `b.``next`   `                ``else``:` `                    ``c ``=` `c.``next` `            ``a ``=` `a.``next` `        ``print``(``"No Triplet found"``)` `        ``return` `False`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``llist1 ``=` `LinkedList()` `    ``llist2 ``=` `LinkedList()` `    ``llist3 ``=` `LinkedList()`   `    ``# Create Linked List llist1 100->15->5->20` `    ``llist1.push(``20``)` `    ``llist1.push(``5``)` `    ``llist1.push(``15``)` `    ``llist1.push(``100``)`   `    ``# create a sorted linked list 'b' 2->4->9->10` `    ``llist2.push(``10``)` `    ``llist2.push(``9``)` `    ``llist2.push(``4``)` `    ``llist2.push(``2``)`   `    ``# create another sorted linked list 'c' 8->4->2->1` `    ``llist3.push(``1``)` `    ``llist3.push(``2``)` `    ``llist3.push(``4``)` `    ``llist3.push(``8``)`   `    ``givenNumber ``=` `25` `    ``llist1.isSumSorted(llist1, llist2, llist3, givenNumber)` `    `  `# This code is contributed by akashish__`

## C#

 `// C# program to find a triplet ` `// from three linked lists with` `// sum equal to a given number` `using` `System;`   `public` `class` `LinkedList` `{` `    ``public` `Node head; ``// head of list`   `    ``/* Linked list Node*/` `    ``public` `class` `Node` `    ``{` `        ``public` `int` `data;` `        ``public` `Node next;` `        ``public` `Node(``int` `d) ` `        ``{` `            ``data = d; next = ``null``;` `        ``}` `    ``}`   `    ``/* A function to check if there ` `    ``are three elements in a, b` `    ``and c whose sum is equal to ` `    ``givenNumber. The function` `    ``assumes that the list b is ` `    ``sorted in ascending order and` `    ``c is sorted in descending order. */` `bool` `isSumSorted(LinkedList la, LinkedList lb, ` `                ``LinkedList lc, ``int` `givenNumber)` `{` `    ``Node a = la.head;`   `    ``// Traverse all nodes of la` `    ``while` `(a != ``null``)` `    ``{` `        ``Node b = lb.head;` `        ``Node c = lc.head;`   `        ``// for every node in la pick ` `        ``// 2 nodes from lb and lc` `        ``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``;` `            ``}`   `            ``// If sum is smaller then ` `            ``// look for greater value of b` `            ``else` `if` `(sum < givenNumber)` `                ``b = b.next;`   `            ``else` `                ``c = c.next;` `        ``}` `        ``a = a.next;` `    ``}` `    ``Console.WriteLine(``"No Triplet found"``);` `    ``return` `false``;` `}`     `    ``/* Given a reference (pointer to pointer) to the head` `    ``of a list and an int, push a new node on the front` `    ``of the 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;` `    ``}`   `    ``/* Driver code*/` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``LinkedList llist1 = ``new` `LinkedList();` `        ``LinkedList llist2 = ``new` `LinkedList();` `        ``LinkedList llist3 = ``new` `LinkedList();`   `        ``/* Create Linked List llist1 100->15->5->20 */` `        ``llist1.push(20);` `        ``llist1.push(5);` `        ``llist1.push(15);` `        ``llist1.push(100);`   `        ``/*create a sorted linked list 'b' 2->4->9->10 */` `        ``llist2.push(10);` `        ``llist2.push(9);` `        ``llist2.push(4);` `        ``llist2.push(2);`   `        ``/*create another sorted linked list 'c' 8->4->2->1 */` `        ``llist3.push(1);` `        ``llist3.push(2);` `        ``llist3.push(4);` `        ``llist3.push(8);`   `        ``int` `givenNumber = 25;` `        ``llist1.isSumSorted(llist1,llist2,llist3,givenNumber);` `    ``}` `}`   `// This code contributed by Rajput-Ji`

## Javascript

 `// Javascript code for the above approach` `class Node {` `  ``constructor(data) {` `    ``this``.data = data;` `    ``this``.next = ``null``;` `  ``}` `}`   `class LinkedList {` `  ``constructor() {` `    ``this``.head = ``null``;` `  ``}`   `  ``// function to add new node at the beginning` `  ``push(newData) {` `    ``const newNode = ``new` `Node(newData);` `    ``newNode.next = ``this``.head;` `    ``this``.head = newNode;` `  ``}`   `  ``// A function to check if there ` `  ``// are three elements in a, b` `  ``// and c whose sum is equal to ` `  ``// givenNumber. The function` `  ``// assumes that the list b is ` `  ``// sorted in ascending order and` `  ``// c is sorted in descending order.` `  ``isSumSorted(la, lb, lc, givenNumber) {` `    ``let a = la.head;`   `    ``// Traverse all nodes of la` `    ``while` `(a !== ``null``) {` `      ``let b = lb.head;` `      ``let c = lc.head;`   `      ``// for every node in la pick ` `      ``// 2 nodes from lb and lc` `      ``while` `(b !== ``null` `&& c !== ``null``) {` `        ``const sum = a.data + b.data + c.data;` `        ``if` `(sum === givenNumber) {` `          ``console.log(``"Triplet found"``, a.data, b.data, c.data);` `          ``return` `true``;`   `          ``// If sum is smaller then ` `          ``// look for greater value of b` `        ``} ``else` `if` `(sum < givenNumber) {` `          ``b = b.next;` `        ``} ``else` `{` `          ``c = c.next;` `        ``}` `      ``}` `      ``a = a.next;` `    ``}` `    ``console.log(``"No Triplet found"``);` `    ``return` `false``;` `  ``}` `}`   `// Driver code` `if` `(``typeof` `exports !== ``"undefined"``) {` `  ``exports.LinkedList = LinkedList;` `}`   `// usage` `const llist1 = ``new` `LinkedList();` `const llist2 = ``new` `LinkedList();` `const llist3 = ``new` `LinkedList();`   `// Create Linked List llist1 100->15->5->20` `llist1.push(20);` `llist1.push(5);` `llist1.push(15);` `llist1.push(100);`   `// create a sorted linked list 'b' 2->4->9->10` `llist2.push(10);` `llist2.push(9);` `llist2.push(4);` `llist2.push(2);`   `// create another sorted linked list 'c' 8->4->2->1` `llist3.push(1);` `llist3.push(2);` `llist3.push(4);` `llist3.push(8);`   `const givenNumber = 25;` `llist1.isSumSorted(llist1, llist2, llist3, givenNumber);`   `// This code is contributed by lokeshpotta20.`

Output:

`Triplet Found: 15 2 8`

Time complexity: 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.

Please refer complete article on Find a triplet from three linked lists with sum equal to a given number for more details!

Previous
Next