Find pairs with given product in a sorted Doubly Linked List
Last Updated :
05 Mar, 2023
Given a sorted doubly linked list of positive distinct elements, the task is to find pairs in the doubly linked list whose product is equal to given value x, without using any extra space.
Examples:
Input : List = 1 <=> 2 <=> 4 <=> 5 <=> 6 <=> 8 <=> 9
x = 8
Output: (1, 8), (2, 4)
Input : List = 1 <=> 2 <=> 3 <=> 4 <=> 5 <=> 6 <=> 7
x = 6
Output: (1, 6), (2, 3)
A Simple Approach for this problem is to traverse the linked list using two nested loops and find all pairs and check for the pairs with product equals to x. Time complexity for this problem will be O(n^2), n is total number of nodes in doubly linked list.
An Efficient Solution for this problem is same as this article. Here is the algorithm :
- Initialize two pointer variables to find the candidate elements in the sorted doubly linked list. Initialize first with start of doubly linked list i.e; first=head and initialize second with last node of doubly linked list i.e; second=last_node.
- We initialize first and second pointers as first and last nodes. Here we don’t have random access, so to find second pointer, we traverse the list to initialize second.
- If current product of first and second is less than x, then we move first in forward direction. If current product of first and second element is greater than x, then we move second in backward direction.
- Loop termination conditions are also different from arrays. The loop terminates when either of two pointers become NULL, or they cross each other (second->next = first), or they become same (first == second)
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node *next, *prev;
};
void pairProduct( struct Node* head, int x)
{
struct Node* first = head;
struct Node* second = head;
while (second->next != NULL)
second = second->next;
bool found = false ;
while (first != NULL && second != NULL && first != second
&& second->next != first) {
if ((first->data * second->data) == x) {
found = true ;
cout << "(" << first->data << ", "
<< second->data << ")" << endl;
first = first->next;
second = second->prev;
}
else {
if ((first->data * second->data) < x)
first = first->next;
else
second = second->prev;
}
}
if (found == false )
cout << "No pair found" ;
}
void insert( struct Node** head, int data)
{
struct Node* temp = new Node;
temp->data = data;
temp->next = temp->prev = NULL;
if (!(*head))
(*head) = temp;
else {
temp->next = *head;
(*head)->prev = temp;
(*head) = temp;
}
}
int main()
{
struct Node* head = NULL;
insert(&head, 9);
insert(&head, 8);
insert(&head, 6);
insert(&head, 5);
insert(&head, 4);
insert(&head, 2);
insert(&head, 1);
int x = 8;
pairProduct(head, x);
return 0;
}
|
Java
class GFG {
static class Node {
int data;
Node next, prev;
};
static void pairProduct(Node head, int x)
{
Node first = head;
Node second = head;
while (second.next != null )
second = second.next;
boolean found = false ;
while (first != null && second != null && first != second
&& second.next != first) {
if ((first.data * second.data) == x) {
found = true ;
System.out.println( "(" + first.data + ", "
+ second.data + ")" );
first = first.next;
second = second.prev;
}
else {
if ((first.data * second.data) < x)
first = first.next;
else
second = second.prev;
}
}
if (found == false )
System.out.println( "No pair found" );
}
static Node insert(Node head, int data)
{
Node temp = new Node();
temp.data = data;
temp.next = temp.prev = null ;
if ((head) == null )
(head) = temp;
else {
temp.next = head;
(head).prev = temp;
(head) = temp;
}
return head;
}
public static void main(String args[])
{
Node head = null ;
head = insert(head, 9 );
head = insert(head, 8 );
head = insert(head, 6 );
head = insert(head, 5 );
head = insert(head, 4 );
head = insert(head, 2 );
head = insert(head, 1 );
int x = 8 ;
pairProduct(head, x);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .prev = None
self . next = None
def pairProduct(head, x):
first = head
second = head
while (second. next ! = None ):
second = second. next
found = False
while (first ! = None and second ! = None and
first ! = second and second. next ! = first) :
if ((first.data * second.data) = = x) :
found = True
print ( "(" , first.data, ", " , second.data, ")" )
first = first. next
second = second.prev
else :
if ((first.data * second.data) < x):
first = first. next
else :
second = second.prev
if (found = = False ):
print ( "No pair found" )
def insert(head, data):
temp = Node( 0 )
temp.data = data
temp. next = temp.prev = None
if (head = = None ):
(head) = temp
else :
temp. next = head
(head).prev = temp
(head) = temp
return head
if __name__ = = "__main__" :
head = None
head = insert(head, 9 )
head = insert(head, 8 )
head = insert(head, 6 )
head = insert(head, 5 )
head = insert(head, 4 )
head = insert(head, 2 )
head = insert(head, 1 )
x = 8
pairProduct(head, x)
|
C#
using System;
class GFG {
public class Node {
public int data;
public Node next, prev;
};
static void pairProduct(Node head, int x)
{
Node first = head;
Node second = head;
while (second.next != null )
second = second.next;
bool found = false ;
while (first != null && second != null && first != second
&& second.next != first) {
if ((first.data * second.data) == x) {
found = true ;
Console.WriteLine( "(" + first.data + ", "
+ second.data + ")" );
first = first.next;
second = second.prev;
}
else {
if ((first.data * second.data) < x)
first = first.next;
else
second = second.prev;
}
}
if (found == false )
Console.WriteLine( "No pair found" );
}
static Node insert(Node head, int data)
{
Node temp = new Node();
temp.data = data;
temp.next = temp.prev = null ;
if ((head) == null )
(head) = temp;
else {
temp.next = head;
(head).prev = temp;
(head) = temp;
}
return head;
}
public static void Main(String[] args)
{
Node head = null ;
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
int x = 8;
pairProduct(head, x);
}
}
|
Javascript
<script>
class Node {
constructor() {
this .data = 0;
this .prev = null ;
this .next = null ;
}
}
function pairProduct( head , x) {
first = head;
second = head;
while (second.next != null )
second = second.next;
var found = false ;
while (first != null && second != null && first != second && second.next != first) {
if ((first.data * second.data) == x) {
found = true ;
document.write( "(" + first.data + ", " + second.data + ")<br/>" );
first = first.next;
second = second.prev;
} else {
if ((first.data * second.data) < x)
first = first.next;
else
second = second.prev;
}
}
if (found == false )
document.write( "No pair found" );
}
function insert( head , data) {
temp = new Node();
temp.data = data;
temp.next = temp.prev = null ;
if ((head) == null )
(head) = temp;
else {
temp.next = head;
(head).prev = temp;
(head) = temp;
}
return head;
}
head = null ;
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
var x = 8;
pairProduct(head, x);
</script>
|
Time complexity: O(n)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...