在排序的双向链表中查找具有给定产品的对

给定一个正不同元素的排序双向链表，任务是在双向链表中找到乘积等于给定值 x 的对，而不使用任何额外的空间。
例子：

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)

解决此问题的一种简单方法是使用两个嵌套循环遍历链表并找到所有对并检查乘积等于 x 的对。此问题的时间复杂度为 O(n^2)，n 是双向链表中的节点总数。
此问题的有效解决方案与本文相同。这是算法：

• 初始化两个指针变量，在已排序的双向链表中查找候选元素。首先以双向链表的开头进行初始化，即； first=head并用双向链表的最后一个节点初始化second ，即；第二=最后一个节点。
• 我们将第一个和第二个指针初始化为第一个和最后一个节点。这里我们没有随机访问，所以要找到第二个指针，我们遍历列表来初始化第二个。
• 如果 first 和 second 的当前乘积小于 x，那么我们首先向前移动。如果第一个和第二个元素的当前乘积大于 x，那么我们向后移动第二个。
• 循环终止条件也不同于数组。当两个指针中的任何一个变为 NULL，或者它们相互交叉（second->next = first），或者它们变得相同（first == second）时，循环终止

下面是上述方法的实现：

C++

// C++ program to find a pair with
// given product x in sorted Doubly
// Linked List
#include 
using namespace std;
 
// Doubly Linked List Node
struct Node {
    int data;
    struct Node *next, *prev;
};
 
// Function to find pair whose product
// equal to given value x
void pairProduct(struct Node* head, int x)
{
    // Set two pointers,
    // first to the beginning of DLL
    // and second to the end of DLL.
    struct Node* first = head;
    struct Node* second = head;
    while (second->next != NULL)
        second = second->next;
 
    // To track if we find a pair or not
    bool found = false;
 
    // The loop terminates when either of two pointers
    // become NULL, or they cross each other (second->next
    // == first), or they become same (first == second)
    while (first != NULL && second != NULL && first != second
           && second->next != first) {
        // pair found
        if ((first->data * second->data) == x) {
            found = true;
            cout << "(" << first->data << ", "
                 << second->data << ")" << endl;
 
            // move first in forward direction
            first = first->next;
 
            // move second in backward direction
            second = second->prev;
        }
        else {
            if ((first->data * second->data) < x)
                first = first->next;
            else
                second = second->prev;
        }
    }
 
    // if pair is not present
    if (found == false)
        cout << "No pair found";
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
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;
    }
}
 
// Driver Code
int main()
{
    // Create Doubly Linked List
    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

// Java program to find a pair with
// given product x in sorted Doubly
// Linked List
 
class GFG {
 
    // Doubly Linked List Node
    static class Node {
        int data;
        Node next, prev;
    };
 
    // Function to find pair whose product
    // equal to given value x
    static void pairProduct(Node head, int x)
    {
        // Set two pointers,
        // first to the beginning of DLL
        // and second to the end of DLL.
        Node first = head;
        Node second = head;
        while (second.next != null)
            second = second.next;
 
        // To track if we find a pair or not
        boolean found = false;
 
        // The loop terminates when either of two pointers
        // become null, or they cross each other (second.next
        // == first), or they become same (first == second)
        while (first != null && second != null && first != second
               && second.next != first) {
            // pair found
            if ((first.data * second.data) == x) {
                found = true;
                System.out.println("(" + first.data + ", "
                                   + second.data + ")");
 
                // move first in forward direction
                first = first.next;
 
                // move second in backward direction
                second = second.prev;
            }
            else {
                if ((first.data * second.data) < x)
                    first = first.next;
                else
                    second = second.prev;
            }
        }
 
        // if pair is not present
        if (found == false)
            System.out.println("No pair found");
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    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;
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // Create Doubly Linked List
        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);
    }
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 program to find a pair with
# given product x in sorted Doubly
# Linked List
 
# Node of the doubly linked list
class Node:
     
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None
 
# Function to find pair whose product
# equal to given value x
def pairProduct(head, x):
 
    # Set two pointers,
    # first to the beginning of DLL
    # and second to the end of DLL.
    first = head
    second = head
    while (second.next != None):
        second = second.next
 
    # To track if we find a pair or not
    found = False
 
    # The loop terminates when either of two pointers
    # become None, or they cross each other (second.next
    # == first), or they become same (first == second)
    while (first != None and second != None and
           first != second and second.next != first) :
        # pair found
        if ((first.data * second.data) == x) :
            found = True
            print("(", first.data, ", ", second.data, ")")
 
            # move first in forward direction
            first = first.next
 
            # move second in backward direction
            second = second.prev
         
        else :
            if ((first.data * second.data) < x):
                first = first.next
            else:
                second = second.prev
         
    # if pair is not present
    if (found == False):
        print( "No pair found")
 
# A utility function to insert a new node at the
# beginning of doubly linked list
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
 
# Driver Code
if __name__ == "__main__":
 
    # Create Doubly Linked List
    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)
 
# This code is contributed by Arnab Kundu

C#

// C# program to find a pair with
// given product x in sorted Doubly
// Linked List
using System;
 
class GFG {
 
    // Doubly Linked List Node
    public class Node {
        public int data;
        public Node next, prev;
    };
 
    // Function to find pair whose product
    // equal to given value x
    static void pairProduct(Node head, int x)
    {
        // Set two pointers,
        // first to the beginning of DLL
        // and second to the end of DLL.
        Node first = head;
        Node second = head;
        while (second.next != null)
            second = second.next;
 
        // To track if we find a pair or not
        bool found = false;
 
        // The loop terminates when either of two pointers
        // become null, or they cross each other (second.next
        // == first), or they become same (first == second)
        while (first != null && second != null && first != second
               && second.next != first) {
            // pair found
            if ((first.data * second.data) == x) {
                found = true;
                Console.WriteLine("(" + first.data + ", "
                                  + second.data + ")");
 
                // move first in forward direction
                first = first.next;
 
                // move second in backward direction
                second = second.prev;
            }
            else {
                if ((first.data * second.data) < x)
                    first = first.next;
                else
                    second = second.prev;
            }
        }
 
        // if pair is not present
        if (found == false)
            Console.WriteLine("No pair found");
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    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;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        // Create Doubly Linked List
        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);
    }
}
 
// This code contributed by Rajput-Ji

Javascript

// javascript program to find a pair with
// given product x in sorted Doubly
// Linked List
    // Doubly Linked List Node
class Node {
    constructor() {
        this.data = 0;
        this.prev = null;
        this.next = null;
    }
}
 
 
 
    // Function to find pair whose product
    // equal to given value x
    function pairProduct( head , x) {
        // Set two pointers,
        // first to the beginning of DLL
        // and second to the end of DLL.
         first = head;
         second = head;
        while (second.next != null)
            second = second.next;
 
        // To track if we find a pair or not
        var found = false;
 
        // The loop terminates when either of two pointers
        // become null, or they cross each other (second.next
        // == first), or they become same (first == second)
        while (first != null && second != null && first != second && second.next != first) {
            // pair found
            if ((first.data * second.data) == x) {
                found = true;
                document.write("(" + first.data + ", " + second.data + ")<br/>");
 
                // move first in forward direction
                first = first.next;
 
                // move second in backward direction
                second = second.prev;
            } else {
                if ((first.data * second.data) < x)
                    first = first.next;
                else
                    second = second.prev;
            }
        }
 
        // if pair is not present
        if (found == false)
            document.write("No pair found");
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    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;
    }
 
    // Driver Code
     
        // Create Doubly Linked List
         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);
 
// This code contributed by aashish1995

输出：

(1, 8)
(2, 4)

时间复杂度： O(n)