Skip to content
Related Articles

Related Articles

Improve Article

Find quadruplets with given sum in a Doubly Linked List

  • 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 <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(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
Recommended Articles
Page :