• Difficulty Level : Medium
• Last Updated : 30 Nov, 2021

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 = 7
Output:
-3 2 3 5
-3 3 1 6
Explanation: The quadruplets having sum 7( = X) are: {-3, 2, 3, 5}, {-3, 3, 1, 6}.

Input: LL: -2 ↔ -1 ↔ 0 ↔ 0 ↔ 1 ↔ 2, X = 0
Output:
-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 the 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.
• Move the second pointer to its next pointer.
• Move the first pointer to its next pointer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `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`

## C#

 `// C# program for the above approach` `using` `System;`   `public` `class` `GFG {`   `    ``// structure of node of` `    ``// doubly linked list` `public`    `class` `Node {` `    ``public`    `int` `data;` `    ``public`    `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) {`   `                        ``Console.WriteLine(` `                                ``"("` `+ 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 gauravrajput1`

## Javascript

 ``

Output

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

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :