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

• Last Updated : 30 Nov, 2022

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).`

## 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`

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!

My Personal Notes arrow_drop_up
Related Articles