# Find triplet sum closest to X in a sorted Doubly Linked List (DLL)

• Last Updated : 09 Mar, 2022

Given a sorted doubly linked list of N nodes and an integer X, the task is to find the sum of three nodes in the list which is closest to X

Examples:

Input: DLL: -8 ↔ 2 ↔ 3 ↔ 4 ↔ 5, X = 1
Output: 1
Explanation: The required three integers {-8, 4, 5} whose sum is 1 and is closest to 1.

Input: DLL: 1 ↔ 2 ↔ 3 ↔ 4, X = 3
Output: 6
Explanation: The required three integers are {1, 2, 3} whose sum is 6 and is closest to X = 3.

Naive Approach: The simplest approach to solve the given problem is to generate all possible triplets using three nested loops and then choose the triplet which has the sum closest to X and print the sum of the triplet.

Time Complexity: O(N3)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use 3 pointer technique. Follow the steps below to solve this problem:

• Initialize 4 variables, first and second pointing to the head node of the doubly linked list, i.e., first = head, second = head, and tail and third both initialized to the last node of the doubly linked list.
• Initialize a variable diff, initialized as INT_MAX, which stores the closest sum to X.
• Iterate while the first node is not NULL and perform the following steps:
• Initialize second to the next of first, i.e., second = first→next and third = tail(the last node of doubly linked list).
• Iterate while second and third are not NULL and third is not equal to the second.
• Initialize a variable say, sum as (first→data + second→data + third→data).
• If the absolute value of X – sum is less than the absolute value of X diff, then update the value of diff as sum.
• If sum is less than X, then increment second pointer, i.e., second = second→next.
• Otherwise, decrement third, i.e., third = third→prev.
• Move the first pointer to the next pointer, i.e., first = first→next.
• After completing the above steps, print the value of diff as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Doubly linked list node``struct` `Node {``    ``int` `data;``    ``struct` `Node *next, *prev;``};` `// 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();` `    ``// Fill the data value in it``    ``temp->data = data;``    ``temp->next = temp->prev = NULL;` `    ``// If head is NULL change``    ``// head to temp``    ``if` `((*head) == NULL) {``        ``(*head) = temp;``    ``}` `    ``// Insert the node before head``    ``else` `{``        ``temp->next = *head;``        ``(*head)->prev = temp;``        ``(*head) = temp;``    ``}``}` `// Function to find sum of triplet``// closest to X``void` `closestTripletSum(``struct` `Node* head, ``int` `X)``{``    ``// Points to the first node``    ``// of the triplet``    ``struct` `Node* first = head;` `    ``// Points to the second node``    ``// of the triplet``    ``struct` `Node* second = head->next;` `    ``// Stores the last node of``    ``// doubly linked list``    ``struct` `Node* tail = head;` `    ``// Traverse till end of the list``    ``while` `(tail->next != NULL) {``        ``tail = tail->next;``    ``}` `    ``// Stores the sum closest to X``    ``int` `diff = INT_MAX;` `    ``// Points to the third node``    ``// of the triplet``    ``struct` `Node* third = tail;` `    ``// Iterate till the end of the list``    ``while` `(first != NULL) {``        ``second = first->next;``        ``third = tail;` `        ``while` `(second != NULL && third != NULL``               ``&& third != second) {``            ``int` `sum = (first->data + second->data``                       ``+ third->data);` `            ``// Check if the current sum``            ``// is closest to X``            ``if` `(``abs``(X - sum) < ``abs``(X - diff)) {` `                ``// Update the value of diff``                ``diff = sum;``            ``}` `            ``// Check if sum is less than X``            ``if` `(sum < X) {` `                ``// Increment the second``                ``// pointer``                ``second = second->next;``            ``}``            ``else` `{` `                ``// Decrement the third``                ``// pointer``                ``third = third->prev;``            ``}``        ``}` `        ``// Move the first pointer``        ``// ahead``        ``first = first->next;``    ``}` `    ``// Print the closest sum``    ``cout << diff;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``struct` `Node* head = NULL;``    ``insert(&head, 4);``    ``insert(&head, 3);``    ``insert(&head, 2);``    ``insert(&head, 1);``    ``int` `X = 3;` `    ``// Function Call``    ``closestTripletSum(head, X);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG {` `    ``// Doubly linked list node``    ``static` `class` `Node {``        ``int` `data;``        ``Node next, prev;``    ``};``    ``static` `Node head;``  ` `    ``// Function to insert a new node at``    ``// the beginning of doubly linked``    ``// list``    ``static` `void` `insert(``int` `data)``    ``{``      ` `        ``// Allocate node``        ``Node temp = ``new` `Node();` `        ``// Fill the data value in it``        ``temp.data = data;``        ``temp.next = temp.prev = ``null``;` `        ``// If head is null change``        ``// head to temp``        ``if` `((head) == ``null``) {``            ``(head) = temp;``        ``}` `        ``// Insert the node before head``        ``else` `{``            ``temp.next = head;``            ``(head).prev = temp;``            ``(head) = temp;``        ``}``    ``}` `    ``// Function to find sum of triplet``    ``// closest to X``    ``static` `void` `closestTripletSum(``int` `X)``    ``{``        ``// Points to the first node``        ``// of the triplet``        ``Node first = head;` `        ``// Points to the second node``        ``// of the triplet``        ``Node second = head.next;` `        ``// Stores the last node of``        ``// doubly linked list``        ``Node tail = head;` `        ``// Traverse till end of the list``        ``while` `(tail.next != ``null``) {``            ``tail = tail.next;``        ``}` `        ``// Stores the sum closest to X``        ``int` `diff = Integer.MAX_VALUE;` `        ``// Points to the third node``        ``// of the triplet``        ``Node third = tail;` `        ``// Iterate till the end of the list``        ``while` `(first != ``null``) {``            ``second = first.next;``            ``third = tail;` `            ``while` `(second != ``null` `&& third != ``null``                   ``&& third != second) {``                ``int` `sum = (first.data + second.data``                           ``+ third.data);` `                ``// Check if the current sum``                ``// is closest to X``                ``if` `(Math.abs(X - sum)``                    ``< Math.abs(X - diff)) {` `                    ``// Update the value of diff``                    ``diff = sum;``                ``}` `                ``// Check if sum is less than X``                ``if` `(sum < X) {` `                    ``// Increment the second``                    ``// pointer``                    ``second = second.next;``                ``}``                ``else` `{` `                    ``// Decrement the third``                    ``// pointer``                    ``third = third.prev;``                ``}``            ``}` `            ``// Move the first pointer``            ``// ahead``            ``first = first.next;``        ``}` `        ``// Print the closest sum``        ``System.out.print(diff);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Given Input``        ``head = ``null``;``        ``insert(``4``);``        ``insert(``3``);``        ``insert(``2``);``        ``insert(``1``);``        ``int` `X = ``3``;` `        ``// Function Call``        ``closestTripletSum(X);``    ``}``}` `// This code is contributed by umadevi9616`

## Python3

 `# Python program for the above approach``import` `sys` `# Doubly linked list Node``class` `Node:``    ``def` `__init__(``self``):``        ``self``.data ``=` `0``;``        ``self``.``next` `=` `None``;``        ``self``.prev ``=` `None``;` `head ``=` `None``;` `# Function to insert a new Node at``# the beginning of doubly linked``# list``def` `insert(data):` `    ``# Allocate Node``    ``temp ``=` `Node();` `    ``# Fill the data value in it``    ``temp.data ``=` `data;``    ``temp.``next` `=` `temp.prev ``=` `None``;` `    ``# If head is None change``    ``# head to temp``    ``global` `head;``    ``if` `((head) ``=``=` `None``):``        ``(head) ``=` `temp;``    ` `    ``# Insert the Node before head``    ``else``:``        ``temp.``next` `=` `head;``        ``(head).prev ``=` `temp;``        ``(head) ``=` `temp;``    ` `# Function to find sum of triplet``# closest to X``def` `closestTripletSum(X):``  ` `    ``# Points to the first Node``    ``# of the triplet``    ``first ``=` `head;` `    ``# Points to the second Node``    ``# of the triplet``    ``second ``=` `head.``next``;` `    ``# Stores the last Node of``    ``# doubly linked list``    ``tail ``=` `head;` `    ``# Traverse till end of the list``    ``while` `(tail.``next` `!``=` `None``):``        ``tail ``=` `tail.``next``;``    `  `    ``# Stores the sum closest to X``    ``diff ``=` `sys.maxsize;` `    ``# Points to the third Node``    ``# of the triplet``    ``third ``=` `tail;` `    ``# Iterate till the end of the list``    ``while` `(first !``=` `None``):``        ``second ``=` `first.``next``;``        ``third ``=` `tail;` `        ``while` `(second !``=` `None` `and` `third !``=` `None` `and` `third !``=` `second):``            ``sum` `=` `(first.data ``+` `second.data ``+` `third.data);` `            ``# Check if the current sum``            ``# is closest to X``            ``if` `(``abs``(X ``-` `sum``) < ``abs``(X ``-` `diff)):` `                ``# Update the value of diff``                ``diff ``=` `sum``;``            `  `            ``# Check if sum is less than X``            ``if` `(``sum` `< X):` `                ``# Increment the second``                ``# pointer``                ``second ``=` `second.``next``;``            ``else``:` `                ``# Decrement the third``                ``# pointer``                ``third ``=` `third.prev;``            ` `        ``# Move the first pointer``        ``# ahead``        ``first ``=` `first.``next``;``    ` `    ``# Print the closest sum``    ``print``(diff);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Given Input``    ``head ``=` `None``;``    ``insert(``4``);``    ``insert(``3``);``    ``insert(``2``);``    ``insert(``1``);``    ``X ``=` `3``;` `    ``# Function Call``    ``closestTripletSum(X);` `# This code is contributed by umadevi9616`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG {` `    ``// Doubly linked list node``public`    `class` `Node {``    ``public`    `int` `data;``    ``public`    `Node next, prev;``    ``};` `    ``static` `Node head;` `    ``// Function to insert a new node at``    ``// the beginning of doubly linked``    ``// list``    ``static` `void` `insert(``int` `data) {` `        ``// Allocate node``        ``Node temp = ``new` `Node();` `        ``// Fill the data value in it``        ``temp.data = data;``        ``temp.next = temp.prev = ``null``;` `        ``// If head is null change``        ``// head to temp``        ``if` `((head) == ``null``) {``            ``(head) = temp;``        ``}` `        ``// Insert the node before head``        ``else` `{``            ``temp.next = head;``            ``(head).prev = temp;``            ``(head) = temp;``        ``}``    ``}` `    ``// Function to find sum of triplet``    ``// closest to X``    ``static` `void` `closestTripletSum(``int` `X) {``        ``// Points to the first node``        ``// of the triplet``        ``Node first = head;` `        ``// Points to the second node``        ``// of the triplet``        ``Node second = head.next;` `        ``// Stores the last node of``        ``// doubly linked list``        ``Node tail = head;` `        ``// Traverse till end of the list``        ``while` `(tail.next != ``null``) {``            ``tail = tail.next;``        ``}` `        ``// Stores the sum closest to X``        ``int` `diff = ``int``.MaxValue;` `        ``// Points to the third node``        ``// of the triplet``        ``Node third = tail;` `        ``// Iterate till the end of the list``        ``while` `(first != ``null``) {``            ``second = first.next;``            ``third = tail;` `            ``while` `(second != ``null` `&& third != ``null` `&& third != second) {``                ``int` `sum = (first.data + second.data + third.data);` `                ``// Check if the current sum``                ``// is closest to X``                ``if` `(Math.Abs(X - sum) < Math.Abs(X - diff)) {` `                    ``// Update the value of diff``                    ``diff = sum;``                ``}` `                ``// Check if sum is less than X``                ``if` `(sum < X) {` `                    ``// Increment the second``                    ``// pointer``                    ``second = second.next;``                ``} ``else` `{` `                    ``// Decrement the third``                    ``// pointer``                    ``third = third.prev;``                ``}``            ``}` `            ``// Move the first pointer``            ``// ahead``            ``first = first.next;``        ``}` `        ``// Print the closest sum``        ``Console.Write(diff);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args) {` `        ``// Given Input``        ``head = ``null``;``        ``insert(4);``        ``insert(3);``        ``insert(2);``        ``insert(1);``        ``int` `X = 3;` `        ``// Function Call``        ``closestTripletSum(X);``    ``}``}` `// This code is contributed by umadevi9616`

## Javascript

 ``

Output

`6`

Time Complexity: O(N2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up