 Open in App
Not now

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

• Difficulty Level : Medium
• 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++

 `// 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 of 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 of 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 of 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.