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 = 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:

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

Time Complexity: O(N³)
Auxiliary Space: O(1)