Related Articles

• Difficulty Level : Medium
• Last Updated : 18 Jun, 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`

## Javascript

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

Time Complexity: O(N3)
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.

My Personal Notes arrow_drop_up