 GeeksforGeeks App
Open App Browser
Continue

## Related Articles

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