Count triplets in a sorted doubly linked list whose sum is equal to a given value x
Last Updated :
13 Apr, 2023
Given a sorted doubly linked list of distinct nodes(no two nodes have the same data) and a value x. Count triplets in the list that sum up to a given value x.
Examples:
Method 1 (Naive Approach):
Using three nested loops generate all triplets and check whether elements in the triplet sum up to x or not.
C++
// C++ implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
#include <bits/stdc++.h>
using namespace std;
// structure of node of doubly linked list
struct Node {
int data;
struct Node* next, *prev;
};
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
struct Node* ptr1, *ptr2, *ptr3;
int count = 0;
// generate all possible triplets
for (ptr1 = head; ptr1 != NULL; ptr1 = ptr1->next)
for (ptr2 = ptr1->next; ptr2 != NULL; ptr2 = ptr2->next)
for (ptr3 = ptr2->next; ptr3 != NULL; ptr3 = ptr3->next)
// if elements in the current triplet sum up to 'x'
if ((ptr1->data + ptr2->data + ptr3->data) == x)
// increment count
count++;
// required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
// allocate node
struct Node* temp = new Node();
// put in the data
temp->data = data;
temp->next = temp->prev = NULL;
if ((*head) == NULL)
(*head) = temp;
else {
temp->next = *head;
(*head)->prev = temp;
(*head) = temp;
}
}
// Driver program to test above
int main()
{
// start with an empty doubly linked list
struct Node* head = NULL;
// insert values in sorted order
insert(&head, 9);
insert(&head, 8);
insert(&head, 6);
insert(&head, 5);
insert(&head, 4);
insert(&head, 2);
insert(&head, 1);
int x = 17;
cout << "Count = "
<< countTriplets(head, x);
return 0;
}
// Java implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
import java.io.*;
import java.util.*;
// Represents node of a doubly linked list
class Node
{
int data;
Node prev, next;
Node(int val)
{
data = val;
prev = null;
next = null;
}
}
class GFG
{
// function to count triplets in
// a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
Node ptr1, ptr2, ptr3;
int count = 0;
// generate all possible triplets
for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
// if elements in the current triplet sum up to 'x'
if ((ptr1.data + ptr2.data + ptr3.data) == x)
// increment count
count++;
// required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int val)
{
// allocate node
Node temp = new Node(val);
if (head == null)
head = temp;
else
{
temp.next = head;
head.prev = temp;
head = temp;
}
return head;
}
// Driver code
public static void main(String args[])
{
// start with an empty doubly linked list
Node head = null;
// insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
int x = 17;
System.out.println("count = " + countTriplets(head, x));
}
}
// This code is contributed by rachana soma
# Python3 implementation to count triplets
# in a sorted doubly linked list
# whose sum is equal to a given value 'x'
# structure of node of doubly linked list
class Node:
def __init__(self):
self.data = None
self.prev = None
self.next = None
# function to count triplets in a sorted doubly linked list
# whose sum is equal to a given value 'x'
def countTriplets( head, x):
ptr1 = head
ptr2 = None
ptr3 = None
count = 0
# generate all possible triplets
while (ptr1 != None ):
ptr2 = ptr1.next
while ( ptr2 != None ):
ptr3 = ptr2.next
while ( ptr3 != None ):
# if elements in the current triplet sum up to 'x'
if ((ptr1.data + ptr2.data + ptr3.data) == x):
# increment count
count = count + 1
ptr3 = ptr3.next
ptr2 = ptr2.next
ptr1 = ptr1.next
# required count of triplets
return count
# A utility function to insert a new node at the
# beginning of doubly linked list
def insert(head, data):
# allocate node
temp = Node()
# put in the data
temp.data = data
temp.next = temp.prev = None
if ((head) == None):
(head) = temp
else :
temp.next = head
(head).prev = temp
(head) = temp
return head
# Driver code
# start with an empty doubly linked list
head = None
# insert values in sorted order
head = insert(head, 9)
head = insert(head, 8)
head = insert(head, 6)
head = insert(head, 5)
head = insert(head, 4)
head = insert(head, 2)
head = insert(head, 1)
x = 17
print( "Count = ", countTriplets(head, x))
# This code is contributed by Arnab Kundu
// C# implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
using System;
// Represents node of a doubly linked list
public class Node
{
public int data;
public Node prev, next;
public Node(int val)
{
data = val;
prev = null;
next = null;
}
}
class GFG
{
// function to count triplets in
// a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
Node ptr1, ptr2, ptr3;
int count = 0;
// generate all possible triplets
for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
// if elements in the current triplet sum up to 'x'
if ((ptr1.data + ptr2.data + ptr3.data) == x)
// increment count
count++;
// required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int val)
{
// allocate node
Node temp = new Node(val);
if (head == null)
head = temp;
else
{
temp.next = head;
head.prev = temp;
head = temp;
}
return head;
}
// Driver code
public static void Main(String []args)
{
// start with an empty doubly linked list
Node head = null;
// insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
int x = 17;
Console.WriteLine("count = " + countTriplets(head, x));
}
}
// This code is contributed by Arnab Kundu
<script>
// javascript implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
// Represents node of a doubly linked list
class Node {
constructor(val) {
this.data = val;
this.prev = null;
this.next = null;
}
}
// function to count triplets in
// a sorted doubly linked list
// whose sum is equal to a given value 'x'
function countTriplets( head , x) {
var ptr1, ptr2, ptr3;
var count = 0;
// generate all possible triplets
for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
// if elements in the current triplet sum up to 'x'
if ((ptr1.data + ptr2.data + ptr3.data) == x)
// increment count
count++;
// required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
function insert( head , val) {
// allocate node
temp = new Node(val);
if (head == null)
head = temp;
else {
temp.next = head;
head.prev = temp;
head = temp;
}
return head;
}
// Driver code
// start with an empty doubly linked list
head = null;
// insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
var x = 17;
document.write("count = " + countTriplets(head, x));
// This code is contributed by umadevi9616
</script>
Output:
Count = 2
Time Complexity: O(n3)
Auxiliary Space: O(1)
Method 2 (Hashing):
Create a hash table with (key, value) tuples represented as (node data, node pointer) tuples. Traverse the doubly linked list and store each node's data and its pointer pair(tuple) in the hash table. Now, generate each possible pair of nodes. For each pair of nodes, calculate the p_sum(sum of data in the two nodes) and check whether (x-p_sum) exists in the hash table or not. If it exists, then also verify that the two nodes in the pair are not same to the node associated with (x-p_sum) in the hash table and finally increment count. Return (count / 3) as each triplet is counted 3 times in the above process.
C++
// C++ implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
#include <bits/stdc++.h>
using namespace std;
// structure of node of doubly linked list
struct Node {
int data;
struct Node* next, *prev;
};
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
struct Node* ptr, *ptr1, *ptr2;
int count = 0;
// unordered_map 'um' implemented as hash table
unordered_map<int, Node*> um;
// insert the <node data, node pointer> tuple in 'um'
for (ptr = head; ptr != NULL; ptr = ptr->next)
um[ptr->data] = ptr;
// generate all possible pairs
for (ptr1 = head; ptr1 != NULL; ptr1 = ptr1->next)
for (ptr2 = ptr1->next; ptr2 != NULL; ptr2 = ptr2->next) {
// p_sum - sum of elements in the current pair
int p_sum = ptr1->data + ptr2->data;
// if 'x-p_sum' is present in 'um' and either of the two nodes
// are not equal to the 'um[x-p_sum]' node
if (um.find(x - p_sum) != um.end() && um[x - p_sum] != ptr1
&& um[x - p_sum] != ptr2)
// increment count
count++;
}
// required count of triplets
// division by 3 as each triplet is counted 3 times
return (count / 3);
}
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
// allocate node
struct Node* temp = new Node();
// put in the data
temp->data = data;
temp->next = temp->prev = NULL;
if ((*head) == NULL)
(*head) = temp;
else {
temp->next = *head;
(*head)->prev = temp;
(*head) = temp;
}
}
// Driver program to test above
int main()
{
// start with an empty doubly linked list
struct Node* head = NULL;
// insert values in sorted order
insert(&head, 9);
insert(&head, 8);
insert(&head, 6);
insert(&head, 5);
insert(&head, 4);
insert(&head, 2);
insert(&head, 1);
int x = 17;
cout << "Count = "
<< countTriplets(head, x);
return 0;
}
// Java implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
import java.util.*;
class GFG{
// structure of node of doubly linked list
static class Node {
int data;
Node next, prev;
Node(int val)
{
data = val;
prev = null;
next = null;
}
};
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
Node ptr, ptr1, ptr2;
int count = 0;
// unordered_map 'um' implemented as hash table
HashMap<Integer,Node> um = new HashMap<Integer,Node>();
// insert the <node data, node pointer> tuple in 'um'
for (ptr = head; ptr != null; ptr = ptr.next)
um.put(ptr.data, ptr);
// generate all possible pairs
for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next) {
// p_sum - sum of elements in the current pair
int p_sum = ptr1.data + ptr2.data;
// if 'x-p_sum' is present in 'um' and either of the two nodes
// are not equal to the 'um[x-p_sum]' node
if (um.containsKey(x - p_sum) && um.get(x - p_sum) != ptr1
&& um.get(x - p_sum) != ptr2)
// increment count
count++;
}
// required count of triplets
// division by 3 as each triplet is counted 3 times
return (count / 3);
}
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int val)
{
// allocate node
Node temp = new Node(val);
if (head == null)
head = temp;
else
{
temp.next = head;
head.prev = temp;
head = temp;
}
return head;
}
// Driver program to test above
public static void main(String[] args)
{
// start with an empty doubly linked list
Node head = null;
// insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
int x = 17;
System.out.print("Count = "
+ countTriplets(head, x));
}
}
// This code is contributed by Rajput-Ji
# Python3 implementation to count triplets in a sorted doubly linked list
# whose sum is equal to a given value 'x'
# structure of node of doubly linked list
class Node:
def __init__(self, data):
self.data=data
self.next=None
self.prev=None
# function to count triplets in a sorted doubly linked list
# whose sum is equal to a given value 'x'
def countTriplets(head, x):
ptr2=head
count = 0;
# unordered_map 'um' implemented as hash table
um = dict()
ptr = head
# insert the <node data, node pointer> tuple in 'um'
while ptr!=None:
um[ptr.data] = ptr;
ptr = ptr.next
# generate all possible pairs
ptr1=head
while ptr1!=None:
ptr2 = ptr1.next
while ptr2!=None:
# p_sum - sum of elements in the current pair
p_sum = ptr1.data + ptr2.data;
# if 'x-p_sum' is present in 'um' and either of the two nodes
# are not equal to the 'um[x-p_sum]' node
if ((x-p_sum) in um) and um[x - p_sum] != ptr1 and um[x - p_sum] != ptr2:
# increment count
count+=1
ptr2 = ptr2.next
ptr1 = ptr1.next
# required count of triplets
# division by 3 as each triplet is counted 3 times
return (count // 3);
# A utility function to insert a new node at the
# beginning of doubly linked list
def insert(head, data):
# allocate node
temp = Node(data);
if ((head) == None):
(head) = temp;
else:
temp.next = head;
(head).prev = temp;
(head) = temp;
return head
# Driver program to test above
if __name__=='__main__':
# start with an empty doubly linked list
head = None;
# insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert( head, 1);
x = 17;
print("Count = "+ str(countTriplets(head, x)))
# This code is contributed by rutvik_56
// C# implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
using System;
using System.Collections.Generic;
class GFG
{
// structure of node of doubly linked list
class Node {
public int data;
public Node next, prev;
public Node(int val)
{
data = val;
prev = null;
next = null;
}
};
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
Node ptr, ptr1, ptr2;
int count = 0;
// unordered_map 'um' implemented as hash table
Dictionary<int,Node> um = new Dictionary<int,Node>();
// insert the <node data, node pointer> tuple in 'um'
for (ptr = head; ptr != null; ptr = ptr.next)
if(um.ContainsKey(ptr.data))
um[ptr.data] = ptr;
else
um.Add(ptr.data, ptr);
// generate all possible pairs
for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
{
// p_sum - sum of elements in the current pair
int p_sum = ptr1.data + ptr2.data;
// if 'x-p_sum' is present in 'um' and either of the two nodes
// are not equal to the 'um[x-p_sum]' node
if (um.ContainsKey(x - p_sum) && um[x - p_sum] != ptr1
&& um[x - p_sum] != ptr2)
// increment count
count++;
}
// required count of triplets
// division by 3 as each triplet is counted 3 times
return (count / 3);
}
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int val)
{
// allocate node
Node temp = new Node(val);
if (head == null)
head = temp;
else
{
temp.next = head;
head.prev = temp;
head = temp;
}
return head;
}
// Driver code
public static void Main(String[] args)
{
// start with an empty doubly linked list
Node head = null;
// insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
int x = 17;
Console.Write("Count = "
+ countTriplets(head, x));
}
}
// This code is contributed by PrinciRaj1992
<script>
// Javascript implementation to count
// triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
// Structure of node of doubly linked list
class Node{
constructor(data)
{
this.data = data;
this.prev = null;
this.next = null;
}
}
// Function to count triplets in a sorted
// doubly linked list whose sum is equal
// to a given value 'x'
function countTriplets(head, x)
{
let ptr, ptr1, ptr2;
let count = 0;
// unordered_map 'um' implemented
// as hash table
let um = new Map();
// Insert the <node data, node pointer>
// tuple in 'um'
for(ptr = head; ptr != null; ptr = ptr.next)
um.set(ptr.data, ptr);
// Generate all possible pairs
for(ptr1 = head;
ptr1 != null;
ptr1 = ptr1.next)
for(ptr2 = ptr1.next;
ptr2 != null;
ptr2 = ptr2.next)
{
// p_sum - sum of elements in
// the current pair
let p_sum = ptr1.data + ptr2.data;
// If 'x-p_sum' is present in 'um'
// and either of the two nodes are
// not equal to the 'um[x-p_sum]' node
if (um.has(x - p_sum) &&
um.get(x - p_sum) != ptr1 &&
um.get(x - p_sum) != ptr2)
// Increment count
count++;
}
// Required count of triplets
// division by 3 as each triplet
// is counted 3 times
return (count / 3);
}
// A utility function to insert a new
// node at the beginning of doubly linked list
function insert(head, val)
{
// Allocate node
let temp = new Node(val);
if (head == null)
head = temp;
else
{
temp.next = head;
head.prev = temp;
head = temp;
}
return head;
}
// Driver code
// Start with an empty doubly linked list
let head = null;
// Insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
let x = 17;
document.write("Count = " +
countTriplets(head, x));
// This code is contributed by patel2127
</script>
Output:
Count = 2
Time Complexity: O(n2)
Auxiliary Space: O(n)
Method 3 Efficient Approach(Use of two pointers):
Traverse the doubly linked list from left to right. For each current node during the traversal, initialize two pointers first = pointer to the node next to the current node and last = pointer to the last node of the list. Now, count pairs in the list from first to last pointer that sum up to value (x - current node's data) (algorithm described in this post). Add this count to the total_count of triplets. Pointer to the last node can be found only once in the beginning.
C++
// C++ implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
#include <bits/stdc++.h>
using namespace std;
// structure of node of doubly linked list
struct Node {
int data;
struct Node* next, *prev;
};
// function to count pairs whose sum equal to given 'value'
int countPairs(struct Node* first, struct Node* second, int value)
{
int count = 0;
// The loop terminates when either of two pointers
// become NULL, or they cross each other (second->next
// == first), or they become same (first == second)
while (first != NULL && second != NULL &&
first != second && second->next != first) {
// pair found
if ((first->data + second->data) == value) {
// increment count
count++;
// move first in forward direction
first = first->next;
// move second in backward direction
second = second->prev;
}
// if sum is greater than 'value'
// move second in backward direction
else if ((first->data + second->data) > value)
second = second->prev;
// else move first in forward direction
else
first = first->next;
}
// required count of pairs
return count;
}
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
// if list is empty
if (head == NULL)
return 0;
struct Node* current, *first, *last;
int count = 0;
// get pointer to the last node of
// the doubly linked list
last = head;
while (last->next != NULL)
last = last->next;
// traversing the doubly linked list
for (current = head; current != NULL; current = current->next) {
// for each current node
first = current->next;
// count pairs with sum(x - current->data) in the range
// first to last and add it to the 'count' of triplets
count += countPairs(first, last, x - current->data);
}
// required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
// allocate node
struct Node* temp = new Node();
// put in the data
temp->data = data;
temp->next = temp->prev = NULL;
if ((*head) == NULL)
(*head) = temp;
else {
temp->next = *head;
(*head)->prev = temp;
(*head) = temp;
}
}
// Driver program to test above
int main()
{
// start with an empty doubly linked list
struct Node* head = NULL;
// insert values in sorted order
insert(&head, 9);
insert(&head, 8);
insert(&head, 6);
insert(&head, 5);
insert(&head, 4);
insert(&head, 2);
insert(&head, 1);
int x = 17;
cout << "Count = "
<< countTriplets(head, x);
return 0;
}
// Java implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
import java.util.*;
class GFG{
// structure of node of doubly linked list
static class Node {
int data;
Node next, prev;
};
// function to count pairs whose sum equal to given 'value'
static int countPairs(Node first, Node second, int value)
{
int count = 0;
// The loop terminates when either of two pointers
// become null, or they cross each other (second.next
// == first), or they become same (first == second)
while (first != null && second != null &&
first != second && second.next != first) {
// pair found
if ((first.data + second.data) == value) {
// increment count
count++;
// move first in forward direction
first = first.next;
// move second in backward direction
second = second.prev;
}
// if sum is greater than 'value'
// move second in backward direction
else if ((first.data + second.data) > value)
second = second.prev;
// else move first in forward direction
else
first = first.next;
}
// required count of pairs
return count;
}
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
// if list is empty
if (head == null)
return 0;
Node current, first, last;
int count = 0;
// get pointer to the last node of
// the doubly linked list
last = head;
while (last.next != null)
last = last.next;
// traversing the doubly linked list
for (current = head; current != null; current = current.next) {
// for each current node
first = current.next;
// count pairs with sum(x - current.data) in the range
// first to last and add it to the 'count' of triplets
count += countPairs(first, last, x - current.data);
}
// required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int data)
{
// allocate node
Node temp = new Node();
// put in the data
temp.data = data;
temp.next = temp.prev = null;
if ((head) == null)
(head) = temp;
else {
temp.next = head;
(head).prev = temp;
(head) = temp;
}
return head;
}
// Driver program to test above
public static void main(String[] args)
{
// start with an empty doubly linked list
Node head = null;
// insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
int x = 17;
System.out.print("Count = "
+ countTriplets(head, x));
}
}
// This code is contributed by 29AjayKumar
# Python3 implementation to count triplets
# in a sorted doubly linked list whose sum
# is equal to a given value 'x'
# Structure of node of doubly linked list
class Node:
def __init__(self, x):
self.data = x
self.next = None
self.prev = None
# Function to count pairs whose sum
# equal to given 'value'
def countPairs(first, second, value):
count = 0
# The loop terminates when either of two pointers
# become None, or they cross each other (second.next
# == first), or they become same (first == second)
while (first != None and second != None and
first != second and second.next != first):
# Pair found
if ((first.data + second.data) == value):
# Increment count
count += 1
# Move first in forward direction
first = first.next
# Move second in backward direction
second = second.prev
# If sum is greater than 'value'
# move second in backward direction
elif ((first.data + second.data) > value):
second = second.prev
# Else move first in forward direction
else:
first = first.next
# Required count of pairs
return count
# Function to count triplets in a sorted
# doubly linked list whose sum is equal
# to a given value 'x'
def countTriplets(head, x):
# If list is empty
if (head == None):
return 0
current, first, last = head, None, None
count = 0
# Get pointer to the last node of
# the doubly linked list
last = head
while (last.next != None):
last = last.next
# Traversing the doubly linked list
while current != None:
# For each current node
first = current.next
# count pairs with sum(x - current.data) in
# the range first to last and add it to the
# 'count' of triplets
count, current = count + countPairs(
first, last, x - current.data), current.next
# Required count of triplets
return count
# A utility function to insert a new node
# at the beginning of doubly linked list
def insert(head, data):
# Allocate node
temp = Node(data)
# Put in the data
# temp.next = temp.prev = None
if (head == None):
head = temp
else:
temp.next = head
head.prev = temp
head = temp
return head
# Driver code
if __name__ == '__main__':
# Start with an empty doubly linked list
head = None
# Insert values in sorted order
head = insert(head, 9)
head = insert(head, 8)
head = insert(head, 6)
head = insert(head, 5)
head = insert(head, 4)
head = insert(head, 2)
head = insert(head, 1)
x = 17
print("Count = ", countTriplets(head, x))
# This code is contributed by mohit kumar 29
// C# implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
using System;
class GFG
{
// structure of node of doubly linked list
class Node
{
public int data;
public Node next, prev;
};
// function to count pairs whose sum equal to given 'value'
static int countPairs(Node first, Node second, int value)
{
int count = 0;
// The loop terminates when either of two pointers
// become null, or they cross each other (second.next
// == first), or they become same (first == second)
while (first != null && second != null &&
first != second && second.next != first) {
// pair found
if ((first.data + second.data) == value) {
// increment count
count++;
// move first in forward direction
first = first.next;
// move second in backward direction
second = second.prev;
}
// if sum is greater than 'value'
// move second in backward direction
else if ((first.data + second.data) > value)
second = second.prev;
// else move first in forward direction
else
first = first.next;
}
// required count of pairs
return count;
}
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
// if list is empty
if (head == null)
return 0;
Node current, first, last;
int count = 0;
// get pointer to the last node of
// the doubly linked list
last = head;
while (last.next != null)
last = last.next;
// traversing the doubly linked list
for (current = head; current != null; current = current.next) {
// for each current node
first = current.next;
// count pairs with sum(x - current.data) in the range
// first to last and add it to the 'count' of triplets
count += countPairs(first, last, x - current.data);
}
// required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int data)
{
// allocate node
Node temp = new Node();
// put in the data
temp.data = data;
temp.next = temp.prev = null;
if ((head) == null)
(head) = temp;
else {
temp.next = head;
(head).prev = temp;
(head) = temp;
}
return head;
}
// Driver program to test above
public static void Main(String[] args)
{
// start with an empty doubly linked list
Node head = null;
// insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
int x = 17;
Console.Write("Count = "
+ countTriplets(head, x));
}
}
// This code is contributed by 29AjayKumar
<script>
// Javascript implementation to count
// triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
// Structure of node of doubly linked list
class Node
{
constructor(data)
{
this.data = data;
this.next = this.prev = null;
}
}
// Function to count pairs whose sum
// equal to given 'value'
function countPairs(first, second, value)
{
let count = 0;
// The loop terminates when either of two pointers
// become null, or they cross each other (second.next
// == first), or they become same (first == second)
while (first != null && second != null &&
first != second && second.next != first)
{
// Pair found
if ((first.data + second.data) == value)
{
// Increment count
count++;
// Move first in forward direction
first = first.next;
// Move second in backward direction
second = second.prev;
}
// If sum is greater than 'value'
// move second in backward direction
else if ((first.data + second.data) > value)
second = second.prev;
// Else move first in forward direction
else
first = first.next;
}
// Required count of pairs
return count;
}
// Function to count triplets in a sorted
// doubly linked list whose sum is equal
// to a given value 'x'
function countTriplets(head, x)
{
// If list is empty
if (head == null)
return 0;
let current, first, last;
let count = 0;
// Get pointer to the last node of
// the doubly linked list
last = head;
while (last.next != null)
last = last.next;
// Traversing the doubly linked list
for(current = head;
current != null;
current = current.next)
{
// For each current node
first = current.next;
// Count pairs with sum(x - current.data)
// in the range first to last and add it
// to the 'count' of triplets
count += countPairs(first, last,
x - current.data);
}
// Required count of triplets
return count;
}
// A utility function to insert a new node at the
// beginning of doubly linked list
function insert(head, data)
{
// Allocate node
let temp = new Node();
// Put in the data
temp.data = data;
temp.next = temp.prev = null;
if ((head) == null)
(head) = temp;
else
{
temp.next = head;
(head).prev = temp;
(head) = temp;
}
return head;
}
// Driver code
// Start with an empty doubly linked list
let head = null;
// Insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
let x = 17;
document.write("Count = " +
countTriplets(head, x));
// This code is contributed by unknown2108
</script>
Output:
Count = 2
Time Complexity: O(n2)
Auxiliary Space: O(1)
Another Solution
find tripple sum in Doubly linkedList.
C++
#include <iostream>
#include <vector>
using namespace std;
struct Node
{
int data;
Node *next;
Node *prev;
Node(int x)
{
data = x;
next = nullptr;
prev = nullptr;
}
};
class Solution
{
public:
vector<vector<int>> trippleSumInLinkedList(Node *head, int sumv)
{
vector<vector<int>> res;
Node *s, *m, *e;
s = head;
m = head;
e = head;
while (e->next != nullptr)
e = e->next;
while (s->next->next != nullptr)
{
int currSum = sumv - s->data;
m = s->next;
Node *ev = e;
while (m != nullptr && ev != nullptr && m != ev)
{
int newSum = m->data + ev->data;
if (newSum == currSum)
{
res.push_back({s->data, m->data, ev->data});
m = m->next;
}
else if (newSum > currSum)
ev = ev->prev;
else
m = m->next;
}
s = s->next;
}
return res;
}
};
int main()
{
Node *head = new Node(1);
Node *node2 = new Node(2);
Node *node3 = new Node(4);
Node *node4 = new Node(5);
Node *node5 = new Node(6);
Node *node6 = new Node(8);
Node *node7 = new Node(9);
head->next = node2;
node2->prev = head;
node2->next = node3;
node3->prev = node2;
node3->next = node4;
node4->next = node5;
node4->prev = node3;
node5->prev = node4;
node5->next = node6;
node6->prev = node5;
node6->next = node7;
node7->prev = node6;
Solution sol;
vector<vector<int>> res = sol.trippleSumInLinkedList(head, 15);
for (int i = 0; i < res.size(); i++)
cout << res[i][0] << ", " << res[i][1] << ", " << res[i][2] << endl;
return 0;
}
import java.util.ArrayList;
class Node {
public int data;
public Node next;
public Node prev;
public Node(int x) {
data = x;
next = null;
prev = null;
}
}
public class Solution {
public ArrayList<ArrayList<Integer>> trippleSumInLinkedList(Node head, int sumv) {
ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
Node s, m, e;
s = head;
m = head;
e = head;
while (e.next != null)
e = e.next;
while (s.next.next != null) {
int currSum = sumv - s.data;
m = s.next;
Node ev = e;
while (m != null && ev != null && m != ev) {
int newSum = m.data + ev.data;
if (newSum == currSum) {
ArrayList<Integer> triple = new ArrayList<Integer>();
triple.add(s.data);
triple.add(m.data);
triple.add(ev.data);
res.add(triple);
m = m.next;
}
else if (newSum > currSum)
ev = ev.prev;
else
m = m.next;
}
s = s.next;
}
return res;
}
public static void main(String[] args) {
Node head = new Node(1);
Node node2 = new Node(2);
Node node3 = new Node(4);
Node node4 = new Node(5);
Node node5 = new Node(6);
Node node6 = new Node(8);
Node node7 = new Node(9);
head.next = node2;
node2.prev = head;
node2.next = node3;
node3.prev = node2;
node3.next = node4;
node4.next = node5;
node4.prev = node3;
node5.prev = node4;
node5.next = node6;
node6.prev = node5;
node6.next = node7;
node7.prev = node6;
Solution sol = new Solution();
ArrayList<ArrayList<Integer>> res = sol.trippleSumInLinkedList(head, 15);
for (int i = 0; i < res.size(); i++)
System.out.println(res.get(i).get(0) + ", " + res.get(i).get(1) + ", " + res.get(i).get(2));
}
}
class Solution:
def trippleSumInLinkedList(self, head,sumv):
res = []
s,m,e = head,head,head
while e.next != None:
e = e.next
while s.next.next != None:
currSum = sumv-s.data
m = s.next
ev = e
while m and ev and m != ev:
newSum = m.data + ev.data
if newSum == currSum:
res.append([s.data,m.data,ev.data])
m = m.next
elif newSum > currSum:
ev = ev.prev
else:
m= m.next
s = s.next
return res
sol = Solution()
head = Node(1)
node2 = Node(2)
node3 = Node(4)
node4 = Node(5)
node5 = Node(6)
node6 = Node(8)
node7 = Node(9)
head.next = node2
node2.prev = head
node2.next= node3
node3.prev = node2
node3.next = node4
node4.next= node5
node4.prev = node3
node5.prev = node4
node5.next = node6
node6.prev = node5
node6.next = node7
node7.prev= node6
print('solution: ',sol.trippleSumInLinkedList(head,15))
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node next;
public Node prev;
public Node(int x)
{
data = x;
next = null;
prev = null;
}
}
class Solution {
public List<List<int> >
trippleSumInLinkedList(Node head, int sumv)
{
List<List<int> > res = new List<List<int> >();
Node s, m, e;
s = head;
m = head;
e = head;
while (e.next != null)
e = e.next;
while (s.next.next != null) {
int currSum = sumv - s.data;
m = s.next;
Node ev = e;
while (m != null && ev != null && m != ev) {
int newSum = m.data + ev.data;
if (newSum == currSum) {
res.Add(new List<int>{ s.data, m.data,
ev.data });
m = m.next;
}
else if (newSum > currSum)
ev = ev.prev;
else
m = m.next;
}
s = s.next;
}
return res;
}
}
class Program {
static void Main(string[] args)
{
Node head = new Node(1);
Node node2 = new Node(2);
Node node3 = new Node(4);
Node node4 = new Node(5);
Node node5 = new Node(6);
Node node6 = new Node(8);
Node node7 = new Node(9);
head.next = node2;
node2.prev = head;
node2.next = node3;
node3.prev = node2;
node3.next = node4;
node4.next = node5;
node4.prev = node3;
node5.prev = node4;
node5.next = node6;
node6.prev = node5;
node6.next = node7;
node7.prev = node6;
Solution sol = new Solution();
List<List<int> > res
= sol.trippleSumInLinkedList(head, 15);
foreach(List<int> triple in res)
{
Console.WriteLine("{0}, {1}, {2}", triple[0],
triple[1], triple[2]);
}
Console.ReadKey();
}
}
// This code is contributed by sarojmcy2e
class Node {
constructor(x) {
this.data = x;
this.next = null;
this.prev = null;
}
}
class Solution {
trippleSumInLinkedList(head, sumv) {
let res = [];
let s, m, e;
s = head;
m = head;
e = head;
while (e.next != null)
e = e.next; // move e to the end of the list
while (s.next.next != null) { // iterate through all nodes except last two
let currSum = sumv - s.data; // calculate current sum
m = s.next; // set m to next node of s
let ev = e; // set ev to last node of list
while (m != null && ev != null && m != ev) { // iterate through all nodes between m and ev
let newSum = m.data + ev.data; // calculate new sum
if (newSum == currSum) { // if new sum equals current sum
res.push([s.data, m.data, ev.data]); // add to result array
m = m.next; // move m to next node
} else if (newSum > currSum)
ev = ev.prev; // move ev to previous node
else
m = m.next; // move m to next node
}
s = s.next; // move s to next node
}
return res; // return result array
}
}
let head = new Node(1);
let node2 = new Node(2);
let node3 = new Node(4);
let node4 = new Node(5);
let node5 = new Node(6);
let node6 = new Node(8);
let node7 = new Node(9);
head.next = node2;
node2.prev = head;
node2.next = node3;
node3.prev = node2;
node3.next = node4;
node4.next = node5;
node4.prev = node3;
node5.prev = node4;
node5.next = node6;
node6.prev = node5;
node6.next = node7;
node7.prev = node6;
let sol = new Solution();
let res = sol.trippleSumInLinkedList(head, 15);
for (let i in res)
console.log(res[i][0] + ", " + res[i][1] + ", " + res[i][2]);
Output1, 5, 9
1, 6, 8
2, 4, 9
2, 5, 8
4, 5, 6
Time complexity : O(n^2), where n is the length of the linked list.
Space complexity :O(1),because it only uses a constant amount of extra memory to store pointers to the nodes being examined
Similar Reads
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read
Insertion Sort Algorithm Insertion sort is a simple sorting algorithm that works by iteratively inserting each element of an unsorted list into its correct position in a sorted portion of the list. It is like sorting playing cards in your hands. You split the cards into two groups: the sorted cards and the unsorted cards. T
9 min read
Dijkstra's Algorithm to find Shortest Paths from a Source to all Given a weighted undirected graph represented as an edge list and a source vertex src, find the shortest path distances from the source vertex to all other vertices in the graph. The graph contains V vertices, numbered from 0 to V - 1.Note: The given graph does not contain any negative edge. Example
12 min read
Selection Sort Selection Sort is a comparison-based sorting algorithm. It sorts an array by repeatedly selecting the smallest (or largest) element from the unsorted portion and swapping it with the first unsorted element. This process continues until the entire array is sorted.First we find the smallest element an
8 min read