# Find a triplet from three linked lists with sum equal to a given number

• Difficulty Level : Medium
• Last Updated : 21 Jun, 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++

 `// C++ program to find a triplet ` `// from three linked lists with ` `// sum equal to a given number ` `#include ` `using` `namespace` `std;`   `/* Link list node */` `class` `Node ` `{ ` `    ``public``:` `    ``int` `data; ` `    ``Node* next; ` `}; `   `/* A utility function to insert ` `a node at the beginning of a ` `linked list*/` `void` `push (Node** head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node* new_node = ``new` `Node();`   `    ``/* put in the data */` `    ``new_node->data = new_data; `   `    ``/* link the old list off the new node */` `    ``new_node->next = (*head_ref); `   `    ``/* move the head to point to the new node */` `    ``(*head_ref) = 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. */` `bool` `isSumSorted(Node *headA, Node *headB, ` `                ``Node *headC, ``int` `givenNumber) ` `{ ` `    ``Node *a = headA; `   `    ``// Traverse through all nodes of a ` `    ``while` `(a != NULL) ` `    ``{ ` `        ``Node *b = headB; ` `        ``Node *c = headC; `   `        ``// For every node of list a, prick two nodes ` `        ``// from lists b abd c ` `        ``while` `(b != NULL && c != NULL) ` `        ``{ ` `            ``// If this a triplet with given sum, print ` `            ``// it and return true ` `            ``int` `sum = a->data + b->data + c->data; ` `            ``if` `(sum == givenNumber) ` `            ``{ ` `            ``cout << ``"Triplet Found: "` `<< a->data << ``" "` `<< ` `                                ``b->data << ``" "` `<< c->data; ` `            ``return` `true``; ` `            ``} `   `            ``// If sum of this triplet is smaller, look for ` `            ``// greater values in b ` `            ``else` `if` `(sum < givenNumber) ` `                ``b = b->next; ` `            ``else` `// If sum is greater, look for smaller values in c ` `                ``c = c->next; ` `        ``} ` `        ``a = a->next; ``// Move ahead in list a ` `    ``} `   `    ``cout << ``"No such triplet"``; ` `    ``return` `false``; ` `} `     `/* Driver code*/` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``Node* headA = NULL; ` `    ``Node* headB = NULL; ` `    ``Node* headC = NULL; `   `    ``/*create a linked list 'a' 10->15->5->20 */` `    ``push (&headA, 20); ` `    ``push (&headA, 4); ` `    ``push (&headA, 15); ` `    ``push (&headA, 10); `   `    ``/*create a sorted linked list 'b' 2->4->9->10 */` `    ``push (&headB, 10); ` `    ``push (&headB, 9); ` `    ``push (&headB, 4); ` `    ``push (&headB, 2); `   `    ``/*create another sorted ` `    ``linked list 'c' 8->4->2->1 */` `    ``push (&headC, 1); ` `    ``push (&headC, 2); ` `    ``push (&headC, 4); ` `    ``push (&headC, 8); `   `    ``int` `givenNumber = 25; `   `    ``isSumSorted (headA, headB, headC, givenNumber); `   `    ``return` `0; ` `} `   `// This code is contributed by rathbhupendra`

## C

 `// C program to find a triplet from three linked lists with` `// sum equal to a given number` `#include` `#include` `#include`   `/* Link list node */` `struct` `Node` `{` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `/* A utility function to insert a node at the beginning of a ` `   ``linked list*/` `void` `push (``struct` `Node** head_ref, ``int` `new_data)` `{` `    ``/* allocate node */` `    ``struct` `Node* new_node =` `        ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node));`   `    ``/* put in the data */` `    ``new_node->data = new_data;`   `    ``/* link the old list off the new node */` `    ``new_node->next = (*head_ref);`   `    ``/* move the head to point to the new node */` `    ``(*head_ref) = 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. */` `bool` `isSumSorted(``struct` `Node *headA, ``struct` `Node *headB, ` `                 ``struct` `Node *headC, ``int` `givenNumber)` `{` `    ``struct` `Node *a = headA;`   `    ``// Traverse through all nodes of a` `    ``while` `(a != NULL)` `    ``{` `        ``struct` `Node *b = headB;` `        ``struct` `Node *c = headC;`   `        ``// For every node of list a, prick two nodes` `        ``// from lists b abd c` `        ``while` `(b != NULL && c != NULL)` `        ``{` `            ``// If this a triplet with given sum, print` `            ``// it and return true` `            ``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``;` `            ``}`   `            ``// If sum of this triplet is smaller, look for` `            ``// greater values in b` `            ``else` `if` `(sum < givenNumber)` `                ``b = b->next;` `            ``else` `// If sum is greater, look for smaller values in c` `                ``c = c->next;` `        ``}` `        ``a = a->next;  ``// Move ahead in list a` `    ``}`   `    ``printf` `(``"No such triplet"``);` `    ``return` `false``;` `}`     `/* Driver program to test above function*/` `int` `main()` `{` `    ``/* Start with the empty list */` `    ``struct` `Node* headA = NULL;` `    ``struct` `Node* headB = NULL;` `    ``struct` `Node* headC = NULL;`   `    ``/*create a linked list 'a' 10->15->5->20 */` `    ``push (&headA, 20);` `    ``push (&headA, 4);` `    ``push (&headA, 15);` `    ``push (&headA, 10);`   `    ``/*create a sorted linked list 'b' 2->4->9->10 */` `    ``push (&headB, 10);` `    ``push (&headB, 9);` `    ``push (&headB, 4);` `    ``push (&headB, 2);`   `    ``/*create another sorted linked list 'c' 8->4->2->1 */` `    ``push (&headC, 1);` `    ``push (&headC, 2);` `    ``push (&headC, 4);` `    ``push (&headC, 8);`   `    ``int` `givenNumber = 25;`   `    ``isSumSorted (headA, headB, headC, givenNumber);`   `    ``return` `0;` `}`

## Java

 `// Java program to find a triplet from three linked lists with` `// sum equal to a given number` `class` `LinkedList` `{` `    ``Node head;  ``// head of list`   `    ``/* Linked list Node*/` `    ``class` `Node` `    ``{` `        ``int` `data;` `        ``Node next;` `        ``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. */` `   ``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. */` `    ``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 program to test above functions */` `    ``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 is contributed by Rajat Mishra */`

## Python

 `# Python program to find a triplet ` `# from three linked lists with ` `# sum equal to a given number `   `# Link list node ` `class` `Node: ` `    ``def` `__init__(``self``, new_data): ` `        ``self``.data ``=` `new_data ` `        ``self``.``next` `=` `None`   `# A utility function to insert ` `# a node at the beginning of a ` `# linked list` `def` `push ( head_ref, new_data) :`   `    ``# allocate node ` `    ``new_node ``=` `Node(``0``)`   `    ``# put in the data ` `    ``new_node.data ``=` `new_data `   `    ``# link the old list off the new node ` `    ``new_node.``next` `=` `(head_ref) `   `    ``# move the head to point to the new node ` `    ``(head_ref) ``=` `new_node` `    `  `    ``return` `head_ref;`   `# 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(headA, headB,headC, givenNumber) :`   `    ``a ``=` `headA `   `    ``# Traverse through all nodes of a ` `    ``while` `(a !``=` `None``) :` `    `  `        ``b ``=` `headB ` `        ``c ``=` `headC `   `        ``# For every node of list a, prick two nodes ` `        ``# from lists b abd c ` `        ``while` `(b !``=` `None` `and` `c !``=` `None``) :` `        `  `            ``# If this a triplet with given sum, print ` `            ``# it and return true ` `            ``sum` `=` `a.data ``+` `b.data ``+` `c.data ` `            ``if` `(``sum` `=``=` `givenNumber) :` `            `  `                ``print` `"Triplet Found: "` `, a.data , ``" "` `, b.data , ``" "` `, c.data, ` `                ``return` `True` `            `  `            ``# If sum of this triplet is smaller, look for ` `            ``# greater values in b ` `            ``elif` `(``sum` `< givenNumber): ` `                ``b ``=` `b.``next` `            ``else` `:``# If sum is greater, look for smaller values in c ` `                ``c ``=` `c.``next` `        `  `        ``a ``=` `a.``next` `# Move ahead in list a ` `    `  `    ``print``(``"No such triplet"``) ` `    ``return` `False`   `# Driver code`   `# Start with the empty list ` `headA ``=` `None` `headB ``=` `None` `headC ``=` `None`   `# create a linked list 'a' 10.15.5.20 ` `headA ``=` `push (headA, ``20``) ` `headA ``=` `push (headA, ``4``) ` `headA ``=` `push (headA, ``15``) ` `headA ``=` `push (headA, ``10``) `   `# create a sorted linked list 'b' 2.4.9.10 ` `headB ``=` `push (headB, ``10``) ` `headB ``=` `push (headB, ``9``) ` `headB ``=` `push (headB, ``4``) ` `headB ``=` `push (headB, ``2``) `   `# create another sorted ` `# linked list 'c' 8.4.2.1 ` `headC ``=` `push (headC, ``1``) ` `headC ``=` `push (headC, ``2``) ` `headC ``=` `push (headC, ``4``) ` `headC ``=` `push (headC, ``8``) `   `givenNumber ``=` `25`   `isSumSorted (headA, headB, headC, givenNumber) `   `# This code is contributed by Arnab Kundu`

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

 ``

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.