Python Program for Find a triplet from three linked lists with sum equal to a given number
Last Updated :
03 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.
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
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!
Similar Reads
Find product of nodes whose weights is triangular number in a Linked list Given a linked list with weights, the task is to find the product of nodes whose weights are all triangular numbers where a triangular number is a number that can be represented as the sum of consecutive positive integers starting from 1. In other words, a triangular number is the sum of the first n
7 min read
Count number of triplets with product equal to given number with duplicates allowed Given an array of positive integers (may contain duplicates), the task is to find the number of triplets whose product is equal to a given number t. Examples: Input: arr = [1, 31, 3, 1, 93, 3, 31, 1, 93] t = 93 Output: 18 Input: arr = [4, 2, 4, 2, 3, 1] t = 8 Output: 4 [(4, 2, 1), (4, 2, 1), (2, 4,
15+ min read
Replace Linked List nodes with its closest Tribonacci number Given a singly linked list of integers, the task is to replace every node with its closest Tribonacci number and return the modified linked list. Examples: Input: List: 3 -> 5 -> 9 -> 12Output: 2 -> 4 -> 7 -> 13Explanation: The closest Tribonacci numbers for each node are: Node 1 (
15+ min read
Output of Python Programs | Set 20 (Tuples) Prerequisite: Tuples Note: The output of all these programs is tested on Python3 1. What will be the output of the following program? Python3 tuple = (1, 2, 3, 4) tuple.append( (5, 6, 7) ) print(len(tuple)) Options: 125Error Output: 4. ErrorExplanation: In this case an exception will be thrown as tu
2 min read
Python - Maximum sum of elements of list in a list of lists In this problem, we need to find the maximum sum of elements in a list of lists. A list of lists is a collection of sub-lists and each sub-list contains individual elements. The problem is to find the maximum sum among all the sub-lists. Let's explore various ways to solve this problem.Using sum() w
3 min read
Find common elements in three sorted arrays by dictionary intersection One way to efficiently find shared items in three sorted arrays is by using dictionary intersection. However, it's important to note that dictionaries are commonly used for unique keys, so if there are duplicate elements in your arrays, some adjustments may be needed to make this approach work. Give
4 min read