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

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 <bits/stdc++.h>
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<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
 
/* 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

<script>
// Javascript program to find a triplet from three linked lists with
// sum equal to a given number
 
/* Linked list Node*/
class Node
{
    constructor(d)
    {
        this.data = d;
        this.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. */
function isSumSorted(la,lb,lc,givenNumber)
{
    let a = la;
   
      // Traverse all nodes of la
      while (a != null)
      {
          let b = lb;
          let c = lc;
   
          // for every node in la pick 2 nodes from lb and lc
          while (b != null && c!=null)
          {
              let sum = a.data + b.data + c.data;
              if (sum == givenNumber)
              {
                 document.write("Triplet found " + a.data +
                                     " " + b.data + " " + c.data+"<br>");
                 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;
      }
      document.write("No Triplet found<br>");
      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. */
function push(head_ref,new_data)
{
    /* 1 & 2: Allocate the Node &
                  Put in the data*/
        let new_node = new Node(new_data);
   
        /* 3. Make next of new Node as head */
        new_node.next = (head_ref);
   
        (head_ref) = new_node;
         
        return head_ref;
         
}
 
let headA =null;
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 
let headB = null;
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 
let headC = null;
headC = push (headC, 1) 
headC = push (headC, 2) 
headC = push (headC, 4) 
headC = push (headC, 8) 
   
let givenNumber = 25
   
isSumSorted (headA, headB, headC, givenNumber) 
 
 
// This code is contributed by avanitrachhadiya2155
</script>

Output:

Triplet Found: 15 2 8

Time complexity: O(n²)

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.

This article is compiled by Abhinav Priyadarshi and reviewed by GeeksforGeeks team.

Find all triplets that sum to a given value or less

kartik

Improve

Article Tags :

Practice Tags :

Linked List

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

C++

C

Java

Python

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?