# Find quadruplets with given sum in a Doubly Linked List

Given a sorted doubly linked list and an integer **X**, the task is to print all the quadruplets in the doubly linked list whose sum is **X**.

**Examples:**

Input:LL: -3 ↔ 1 ↔ 2 ↔ 3 ↔ 5 ↔ 6, X = 7Output:-3 2 3 5-3 3 1 6Explanation:The quadruplets having sum 7( = X) are: {-3, 2, 3, 5}, {-3, 3, 1, 6}.

Input:LL:-2 ↔ -1 ↔ 0 ↔ 0 ↔ 1 ↔ 2, X = 0Output:-2 -1 1 2-2 0 0 2-1 0 0 1

**Approach:** The given problem can be solved by using the idea discussed in this article using the 4 pointer technique. Follow the steps below to solve the problem:

- Initialize four variables, say
**first**as the start of the doubly linked list i.e.;**first = head**,**second**to the next of the first pointer,**third**to the next of second pointer, and**fourth**to the last node of a doubly linked list that stores all the 4 elements in the sorted doubly linked list. - Iterate a loop until the
**first**node and the**fourth**node is not**NULL**, and they are not equal and these 2 nodes do not cross each other and perform the following steps:- Initialize the
**second**pointer to the next of**first**. - Iterate a loop until the
**second**and**fourth**nodes are not**NULL**, they are not equal and do not cross each other.- Initialize a variable, say
**sum**as**(X – (first→data + second→data))**, point the**third**pointer to the next of**second**pointer, and take another**temp**pointer initialized to**the last node**i.e., pointer**fourth**. - Iterate a loop while
**temp**and**third**are not**NULL**, they are not equal and do not cross each other- If the value of the
**sum**is**third→data + temp→data**, then print the quadruple and increment the**third pointer**to the next of current**third pointer**and**temp**to the previous of current temp. - If the value of
**sum**is less than the**third→data + temp→data**, then increment the**third**pointer, i.e.,**third = third→next**. - Otherwise, decrement the
**temp**pointer i.e**temp = temp→prev**.

- If the value of the
- Move the
**second**pointer to its next pointer.

- Initialize a variable, say
- Move the
**first**pointer to its next pointer.

- Initialize the

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Structure of node of a doubly` `// linked list` `struct` `Node {` ` ` `int` `data;` ` ` `struct` `Node *next, *prev;` `};` `// Function to insert a new node at` `// the beginning of the doubly linked` `// list` `void` `insert(` `struct` `Node** head, ` `int` `data)` `{` ` ` `// Allocate the node` ` ` `struct` `Node* temp = ` `new` `Node();` ` ` `// Fill in the data value` ` ` `temp->data = data;` ` ` `temp->next = temp->prev = NULL;` ` ` `if` `((*head) == NULL)` ` ` `(*head) = temp;` ` ` `else` `{` ` ` `temp->next = *head;` ` ` `(*head)->prev = temp;` ` ` `(*head) = temp;` ` ` `}` `}` `// Function to print the quadruples` `// having sum equal to x` `void` `PrintFourSum(` `struct` `Node* head, ` `int` `x)` `{` ` ` `// First pointer to the head node` ` ` `struct` `Node* first = head;` ` ` `// Pointer to point to the second` ` ` `// node for the required sum` ` ` `struct` `Node* second;` ` ` `// Pointer to point to the third` ` ` `// node for the required sum` ` ` `struct` `Node* third;` ` ` `// Fourth points to the last node` ` ` `struct` `Node* fourth = head;` ` ` `// Update the fourth pointer to` ` ` `// the end of the DLL` ` ` `while` `(fourth->next != NULL) {` ` ` `fourth = fourth->next;` ` ` `}` ` ` `// Node to point to the fourth node` ` ` `// of the required sum` ` ` `struct` `Node* temp;` ` ` `while` `(first != NULL` ` ` `&& fourth != NULL` ` ` `&& first != fourth` ` ` `&& fourth->next != first) {` ` ` `// Point the second node to the` ` ` `// second element of quadruple` ` ` `second = first->next;` ` ` `while` `(second != NULL` ` ` `&& fourth != NULL` ` ` `&& second != fourth` ` ` `&& fourth->next != second) {` ` ` `int` `reqsum = x - (first->data` ` ` `+ second->data);` ` ` `// Points to the 3rd element` ` ` `// of quadruple` ` ` `third = second->next;` ` ` `// Points to the tail of the DLL` ` ` `temp = fourth;` ` ` `while` `(third != NULL && temp != NULL` ` ` `&& third != temp` ` ` `&& temp->next != third) {` ` ` `// Store the current sum` ` ` `int` `twosum = third->data` ` ` `+ temp->data;` ` ` `// If the sum is equal,` ` ` `// then print quadruple` ` ` `if` `(twosum == reqsum) {` ` ` `cout << ` `"("` `<< first->data` ` ` `<< ` `", "` ` ` `<< second->data` ` ` `<< ` `", "` ` ` `<< third->data` ` ` `<< ` `", "` ` ` `<< temp->data` ` ` `<< ` `")\n"` `;` ` ` `third = third->next;` ` ` `temp = temp->prev;` ` ` `}` ` ` `// If twosum is less than` ` ` `// the reqsum then move the` ` ` `// third pointer to the next` ` ` `else` `if` `(twosum < reqsum) {` ` ` `third = third->next;` ` ` `}` ` ` `// Otherwise move the fourth` ` ` `// pointer to the previous` ` ` `// of the fourth pointer` ` ` `else` `{` ` ` `temp = temp->prev;` ` ` `}` ` ` `}` ` ` `// Move to the next of` ` ` `// the second pointer` ` ` `second = second->next;` ` ` `}` ` ` `// Move to the next of` ` ` `// the first pointer` ` ` `first = first->next;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `struct` `Node* head = NULL;` ` ` `insert(&head, 2);` ` ` `insert(&head, 1);` ` ` `insert(&head, 0);` ` ` `insert(&head, 0);` ` ` `insert(&head, -1);` ` ` `insert(&head, -2);` ` ` `int` `X = 0;` ` ` `PrintFourSum(head, X);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `class` `GFG {` ` ` `// structure of node of` ` ` `// doubly linked list` ` ` `static` `class` `Node {` ` ` `int` `data;` ` ` `Node next, prev;` ` ` `};` ` ` `// A utility function to insert` ` ` `// a new node at the beginning` ` ` `// of the doubly linked list` ` ` `static` `Node insert(Node head, ` `int` `data)` ` ` `{` ` ` `// Allocate the node` ` ` `Node temp = ` `new` `Node();` ` ` `// Fill in the data value` ` ` `temp.data = data;` ` ` `temp.next = temp.prev = ` `null` `;` ` ` `if` `(head == ` `null` `)` ` ` `(head) = temp;` ` ` `else` `{` ` ` `temp.next = head;` ` ` `(head).prev = temp;` ` ` `(head) = temp;` ` ` `}` ` ` `return` `temp;` ` ` `}` ` ` `// Function to print the quadruples` ` ` `// having sum equal to x` ` ` `static` `void` `PrintFourSum(Node head, ` `int` `x)` ` ` `{` ` ` `// First pointer to the head node` ` ` `Node first = head;` ` ` `// Pointer to point to the second` ` ` `// node for the required sum` ` ` `Node second = head;` ` ` `// Pointer to point to the third` ` ` `// node for the required sum` ` ` `Node third = head;` ` ` `// Fourth points to the last node` ` ` `Node fourth = head;` ` ` `// Update the fourth pointer to` ` ` `// the end of the DLL` ` ` `while` `(fourth.next != ` `null` `) {` ` ` `fourth = fourth.next;` ` ` `}` ` ` `// Node to point to the fourth node` ` ` `// of the required sum` ` ` `Node temp;` ` ` `while` `(first != ` `null` `&& fourth != ` `null` ` ` `&& first != fourth && fourth.next != first) {` ` ` `// Point the second node to the` ` ` `// second element of quadruple` ` ` `second = first.next;` ` ` `while` `(second != ` `null` `&& fourth != ` `null` ` ` `&& second != fourth` ` ` `&& fourth.next != second) {` ` ` `int` `reqsum = x - (first.data + second.data);` ` ` `// Points to the 3rd element` ` ` `// of quadruple` ` ` `third = second.next;` ` ` `// Points to the tail of the DLL` ` ` `temp = fourth;` ` ` `while` `(third != ` `null` `&& temp != ` `null` ` ` `&& third != temp` ` ` `&& temp.next != third) {` ` ` `// Store the current sum` ` ` `int` `twosum = third.data + temp.data;` ` ` `// If the sum is equal,` ` ` `// then print quadruple` ` ` `if` `(twosum == reqsum) {` ` ` `System.out.println(` ` ` `"("` `+ first.data + ` `", "` ` ` `+ second.data + ` `", "` ` ` `+ third.data + ` `", "` `+ temp.data` ` ` `+ ` `")"` `);` ` ` `third = third.next;` ` ` `temp = temp.prev;` ` ` `}` ` ` `// If twosum is less than` ` ` `// the reqsum then move the` ` ` `// third pointer to the next` ` ` `else` `if` `(twosum < reqsum) {` ` ` `third = third.next;` ` ` `}` ` ` `// Otherwise move the fourth` ` ` `// pointer to the previous` ` ` `// of the fourth pointer` ` ` `else` `{` ` ` `temp = temp.prev;` ` ` `}` ` ` `}` ` ` `// Move to the next of` ` ` `// the second pointer` ` ` `second = second.next;` ` ` `}` ` ` `// Move to the next of` ` ` `// the first pointer` ` ` `first = first.next;` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` `Node head = ` `null` `;` ` ` `head = insert(head, ` `2` `);` ` ` `head = insert(head, ` `1` `);` ` ` `head = insert(head, ` `0` `);` ` ` `head = insert(head, ` `0` `);` ` ` `head = insert(head, -` `1` `);` ` ` `head = insert(head, -` `2` `);` ` ` `int` `x = ` `0` `;` ` ` `PrintFourSum(head, x);` ` ` `}` `}` `// This code is contributed` `// by kirtishsurangalikar` |

## Python3

`# Python3 program for the above approach` `# Structure of node of a doubly` `# linked list` `class` `Node:` ` ` ` ` `def` `__init__(` `self` `, d):` ` ` ` ` `self` `.data ` `=` `d` ` ` `self` `.left ` `=` `None` ` ` `self` `.right ` `=` `None` `# Function to insert a new node at` `# the beginning of the doubly linked` `# list` `def` `insert(head, data):` ` ` ` ` `# Allocate the node` ` ` `temp ` `=` `Node(data)` ` ` `# Fill in the data value` ` ` `temp.data ` `=` `data` ` ` `temp.` `next` `=` `temp.prev ` `=` `None` ` ` `if` `(head ` `=` `=` `None` `):` ` ` `head ` `=` `temp` ` ` `else` `:` ` ` `temp.` `next` `=` `head` ` ` `head.prev ` `=` `temp` ` ` `head ` `=` `temp` ` ` `return` `head` `# Function to print the quadruples` `# having sum equal to x` `def` `PrintFourSum(head, x):` ` ` ` ` `# First pointer to the head node` ` ` `first ` `=` `head` ` ` `# Pointer to point to the second` ` ` `# node for the required sum` ` ` `second ` `=` `None` ` ` `# Pointer to point to the third` ` ` `# node for the required sum` ` ` `third ` `=` `None` ` ` `# Fourth points to the last node` ` ` `fourth ` `=` `head` ` ` `# Update the fourth pointer to` ` ` `# the end of the DLL` ` ` `while` `(fourth.` `next` `!` `=` `None` `):` ` ` `fourth ` `=` `fourth.` `next` ` ` `# Node to point to the fourth node` ` ` `# of the required sum` ` ` `temp ` `=` `None` ` ` `while` `(first !` `=` `None` `and` ` ` `fourth !` `=` `None` `and` ` ` `first !` `=` `fourth ` `and` ` ` `fourth.` `next` `!` `=` `first):` ` ` `# Point the second node to the` ` ` `# second element of quadruple` ` ` `second ` `=` `first.` `next` ` ` `while` `(second !` `=` `None` `and` ` ` `fourth !` `=` `None` `and` ` ` `second !` `=` `fourth ` `and` ` ` `fourth.` `next` `!` `=` `second):` ` ` `reqsum ` `=` `x ` `-` `(first.data ` `+` ` ` `second.data)` ` ` `# Points to the 3rd element` ` ` `# of quadruple` ` ` `third ` `=` `second.` `next` ` ` `# Points to the tail of the DLL` ` ` `temp ` `=` `fourth` ` ` `while` `(third !` `=` `None` `and` `temp !` `=` `None` `and` ` ` `third !` `=` `temp ` `and` `temp.` `next` `!` `=` `third):` ` ` `# Store the current sum` ` ` `twosum ` `=` `third.data ` `+` `temp.data` ` ` `# If the sum is equal,` ` ` `# then print quadruple` ` ` `if` `(twosum ` `=` `=` `reqsum):` ` ` `print` `(` `"("` `+` `str` `(first.data) ` `+` ` ` `", "` `+` `str` `(second.data) ` `+` ` ` `", "` `+` `str` `(third.data) ` `+` ` ` `", "` `+` `str` `(temp.data) ` `+` `")"` `)` ` ` `third ` `=` `third.` `next` ` ` `temp ` `=` `temp.prev` ` ` `# If twosum is less than` ` ` `# the reqsum then move the` ` ` `# third pointer to the next` ` ` `elif` `(twosum < reqsum):` ` ` `third ` `=` `third.` `next` ` ` ` ` `# Otherwise move the fourth` ` ` `# pointer to the previous` ` ` `# of the fourth pointer` ` ` `else` `:` ` ` `temp ` `=` `temp.prev` ` ` `# Move to the next of` ` ` `# the second pointer` ` ` `second ` `=` `second.` `next` ` ` `# Move to the next of` ` ` `# the first pointer` ` ` `first ` `=` `first.` `next` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `head ` `=` `None` ` ` `head ` `=` `insert(head, ` `2` `)` ` ` `head ` `=` `insert(head, ` `1` `)` ` ` `head ` `=` `insert(head, ` `0` `)` ` ` `head ` `=` `insert(head, ` `0` `)` ` ` `head ` `=` `insert(head, ` `-` `1` `)` ` ` `head ` `=` `insert(head, ` `-` `2` `)` ` ` `X ` `=` `0` ` ` ` ` `PrintFourSum(head, X)` ` ` `# This code is contributed by mohit kumar 29` |

## Javascript

`<script>` `// Javascript program for the above approach` `// Structure of node of a doubly` `// linked list` `class Node {` ` ` `constructor()` ` ` `{` ` ` `this` `.data = 0;` ` ` `this` `.next = ` `null` `;` ` ` `this` `.prev = ` `null` `;` ` ` `}` `};` `// Function to insert a new node at` `// the beginning of the doubly linked` `// list` `function` `insert(head, data)` `{` ` ` `// Allocate the node` ` ` `var` `temp = ` `new` `Node();` ` ` `// Fill in the data value` ` ` `temp.data = data;` ` ` `temp.next = temp.prev = ` `null` `;` ` ` `if` `((head) == ` `null` `)` ` ` `(head) = temp;` ` ` `else` `{` ` ` `temp.next = head;` ` ` `(head).prev = temp;` ` ` `(head) = temp;` ` ` `}` ` ` `return` `head;` `}` `// Function to print the quadruples` `// having sum equal to x` `function` `PrintFourSum(head, x)` `{` ` ` `// First pointer to the head node` ` ` `var` `first = head;` ` ` `// Pointer to point to the second` ` ` `// node for the required sum` ` ` `var` `second;` ` ` `// Pointer to point to the third` ` ` `// node for the required sum` ` ` `var` `third;` ` ` `// Fourth points to the last node` ` ` `var` `fourth = head;` ` ` `// Update the fourth pointer to` ` ` `// the end of the DLL` ` ` `while` `(fourth.next != ` `null` `) {` ` ` `fourth = fourth.next;` ` ` `}` ` ` `// Node to point to the fourth node` ` ` `// of the required sum` ` ` `var` `temp;` ` ` `while` `(first != ` `null` ` ` `&& fourth != ` `null` ` ` `&& first != fourth` ` ` `&& fourth.next != first) {` ` ` `// Point the second node to the` ` ` `// second element of quadruple` ` ` `second = first.next;` ` ` `while` `(second != ` `null` ` ` `&& fourth != ` `null` ` ` `&& second != fourth` ` ` `&& fourth.next != second) {` ` ` `var` `reqsum = x - (first.data` ` ` `+ second.data);` ` ` `// Points to the 3rd element` ` ` `// of quadruple` ` ` `third = second.next;` ` ` `// Points to the tail of the DLL` ` ` `temp = fourth;` ` ` `while` `(third != ` `null` `&& temp != ` `null` ` ` `&& third != temp` ` ` `&& temp.next != third) {` ` ` `// Store the current sum` ` ` `var` `twosum = third.data` ` ` `+ temp.data;` ` ` `// If the sum is equal,` ` ` `// then print quadruple` ` ` `if` `(twosum == reqsum) {` ` ` `document.write( ` `"("` `+ first.data` ` ` `+ ` `", "` ` ` `+ second.data` ` ` `+ ` `", "` ` ` `+ third.data` ` ` `+ ` `", "` ` ` `+ temp.data` ` ` `+ ` `")<br>"` `);` ` ` `third = third.next;` ` ` `temp = temp.prev;` ` ` `}` ` ` `// If twosum is less than` ` ` `// the reqsum then move the` ` ` `// third pointer to the next` ` ` `else` `if` `(twosum < reqsum) {` ` ` `third = third.next;` ` ` `}` ` ` `// Otherwise move the fourth` ` ` `// pointer to the previous` ` ` `// of the fourth pointer` ` ` `else` `{` ` ` `temp = temp.prev;` ` ` `}` ` ` `}` ` ` `// Move to the next of` ` ` `// the second pointer` ` ` `second = second.next;` ` ` `}` ` ` `// Move to the next of` ` ` `// the first pointer` ` ` `first = first.next;` ` ` `}` `}` `// Driver Code` `var` `head = ` `null` `;` `head = insert(head, 2);` `head = insert(head, 1);` `head = insert(head, 0);` `head = insert(head, 0);` `head = insert(head, -1);` `head = insert(head, -2);` `var` `X = 0;` `PrintFourSum(head, X);` `// This code is contributed by rrrtnx.` `</script>` |

**Output**

(-2, -1, 1, 2) (-2, 0, 0, 2) (-1, 0, 0, 1)

**Time Complexity:** O(N^{3})**Auxiliary Space:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.