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

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.

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

**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!