Producto de todos los Nodes en una lista doblemente enlazada divisible por un número dado K

Dada una lista doblemente enlazada que contiene N Nodes y dado un número K. La tarea es encontrar el producto de todos esos Nodes que son divisibles por K.

Ejemplos : 

Input : List = 15 <=> 16 <=> 10 <=> 9 <=> 6 <=> 7 <=> 17
        K = 3
Output : Product = 810

Input : List = 5 <=> 3 <=> 6 <=> 8 <=> 4 <=> 1 <=> 2 <=> 9
        K = 2
Output : Product = 384

La idea es recorrer la lista doblemente enlazada y verificar los Nodes uno por uno. Si el valor de un Node es divisible por K, multiplique el valor de ese Node con el producto hasta el momento y continúe con este proceso hasta que no llegue al final de la lista.

A continuación se muestra la implementación del enfoque anterior:  

// C++ program to find product of nodes in a
// doubly linked list divisible by K
 
#include <iostream>
using namespace std;
 
// Doubly linked list node
struct Node {
    int data;
    Node *prev, *next;
};
 
// function to insert a node at the beginning
// of the Doubly Linked List
void push(Node** head_ref, int new_data)
{
    // allocate node
    Node* new_node = new Node();
 
    // put in the data
    new_node->data = new_data;
 
    // since we are adding at the beginning,
    // prev is always NULL
    new_node->prev = NULL;
 
    // link the old list off the new node
    new_node->next = (*head_ref);
 
    // change prev of head node to new node
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;
 
    // move the head to point to the new node
    (*head_ref) = new_node;
}
 
// Function to find the product of all the nodes from
// the doubly linked list that is divisible by K
int productOfNode(Node** head_ref, int K)
{
    Node* ptr = *head_ref;
    Node* next;
 
    int product = 1;
 
    // Traverse list till last node
    while (ptr != NULL) {
        next = ptr->next;
        // check is node value divided by K
        // if true then add in sum
        if (ptr->data % K == 0)
            product *= ptr->data;
        ptr = next;
    }
 
    // Return product of nodes which
    // are divisible by K
    return product;
}
 
// Driver Code
int main()
{
    // start with the empty list
    Node* head = NULL;
 
    // create the doubly linked list
    // 15 16 10 9 6 7 17
    push(&head, 17);
    push(&head, 7);
    push(&head, 6);
    push(&head, 9);
    push(&head, 10);
    push(&head, 16);
    push(&head, 15);
 
    int K = 3;
 
    int prod = productOfNode(&head, K);
 
    cout << "Product = " << prod;
 
    return 0;
}

// Java program to find product of nodes in a
// doubly linked list divisible by K
class GFG
{
 
// Doubly linked list node
static class Node
{
    int data;
    Node prev, next;
};
 
// function to insert a node at the beginning
// of the Doubly Linked List
static Node push(Node head_ref, int new_data)
{
    // allocate node
    Node new_node = new Node();
 
    // put in the data
    new_node.data = new_data;
 
    // since we are adding at the beginning,
    // prev is always null
    new_node.prev = null;
 
    // link the old list off the new node
    new_node.next = (head_ref);
 
    // change prev of head node to new node
    if ((head_ref) != null)
        (head_ref).prev = new_node;
 
    // move the head to point to the new node
    (head_ref) = new_node;
    return head_ref;
}
 
// Function to find product of all the nodes from
// the doubly linked list that are divisible by K
static int productOfNode(Node head_ref, int K)
{
    Node ptr = head_ref;
    Node next;
 
    int product = 1;
 
    // Traverse list till last node
    while (ptr != null)
    {
        next = ptr.next;
         
        // check is node value divided by K
        // if true then add in sum
        if (ptr.data % K == 0)
            product *= ptr.data;
        ptr = next;
    }
 
    // Return product of nodes which
    // are divisible by K
    return product;
}
 
// Driver Code
public static void main(String args[])
{
    // start with the empty list
    Node head = null;
 
    // create the doubly linked list
    // 15 16 10 9 6 7 17
    head = push(head, 17);
    head = push(head, 7);
    head = push(head, 6);
    head = push(head, 9);
    head = push(head, 10);
    head = push(head, 16);
    head = push(head, 15);
 
    int K = 3;
 
    int prod = productOfNode(head, K);
 
    System.out.println( "Product = " + prod);
}
}
 
// This code is contributed by Arnab Kundu

# Python3 program to find product of nodes in a
# doubly linked list divisible by K
 
# Node of the doubly linked list
class Node:
     
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None
 
# function to insert a node at the beginning
# of the Doubly Linked List
def push(head_ref, new_data):
 
    # allocate node
    new_node = Node(0)
 
    # put in the data
    new_node.data = new_data
 
    # since we are multiplying at the beginning,
    # prev is always None
    new_node.prev = None
 
    # link the old list off the new node
    new_node.next = (head_ref)
 
    # change prev of head node to new node
    if ((head_ref) != None):
        (head_ref).prev = new_node
 
    # move the head to point to the new node
    (head_ref) = new_node
    return head_ref
 
# function to product all the nodes
# from the doubly linked
# list that are divided by K
def productOfNode(head_ref, K):
 
    ptr = head_ref
    next = None
     
    # variable product=1
    product = 1
     
    # traverse list till last node
    while (ptr != None) :
        next = ptr.next
         
        # check is node value divided by K
        # if true then multiply in product
        if (ptr.data % K == 0):
            product *= ptr.data
        ptr = next
     
    # return product of nodes which is divided by K
    return product
 
# Driver Code
if __name__ == "__main__":
 
    # start with the empty list
    head = None
 
    # create the doubly linked list
    # 15 <. 16 <. 10 <. 9 <. 6 <. 7 <. 17
    head = push(head, 17)
    head = push(head, 7)
    head = push(head, 6)
    head = push(head, 9)
    head = push(head, 10)
    head = push(head, 16)
    head = push(head, 15)
     
    K = 3
     
    product = productOfNode(head, K)
    print("product =", product)
 
# This code is contributed by Arnab Kundu

// C# program to find product of nodes in a
// doubly linked list divisible by K
using System;
 
class GFG
{
 
// Doubly linked list node
public class Node
{
    public int data;
    public Node prev, next;
};
 
// function to insert a node at the beginning
// of the Doubly Linked List
static Node push(Node head_ref, int new_data)
{
    // allocate node
    Node new_node = new Node();
 
    // put in the data
    new_node.data = new_data;
 
    // since we are adding at the beginning,
    // prev is always null
    new_node.prev = null;
 
    // link the old list off the new node
    new_node.next = (head_ref);
 
    // change prev of head node to new node
    if ((head_ref) != null)
        (head_ref).prev = new_node;
 
    // move the head to point to the new node
    (head_ref) = new_node;
    return head_ref;
}
 
// Function to find product of all the nodes from
// the doubly linked list that are divisible by K
static int productOfNode(Node head_ref, int K)
{
    Node ptr = head_ref;
    Node next;
 
    int product = 1;
 
    // Traverse list till last node
    while (ptr != null)
    {
        next = ptr.next;
         
        // check is node value divided by K
        // if true then add in sum
        if (ptr.data % K == 0)
            product *= ptr.data;
        ptr = next;
    }
 
    // Return product of nodes which
    // are divisible by K
    return product;
}
 
// Driver Code
public static void Main(String []args)
{
    // start with the empty list
    Node head = null;
 
    // create the doubly linked list
    // 15 16 10 9 6 7 17
    head = push(head, 17);
    head = push(head, 7);
    head = push(head, 6);
    head = push(head, 9);
    head = push(head, 10);
    head = push(head, 16);
    head = push(head, 15);
 
    int K = 3;
 
    int prod = productOfNode(head, K);
 
    Console.WriteLine( "Product = " + prod);
}
}
 
// This code contributed by Rajput-Ji

<script>
// javascript program to find product of nodes in a
// doubly linked list divisible by K    
// Doubly linked list node
class Node {
    constructor(val) {
        this.data = val;
        this.prev = null;
        this.next = null;
    }
}
 
    // function to insert a node at the beginning
    // of the Doubly Linked List
    function push(head_ref , new_data) {
        // allocate node
var new_node = new Node();
 
        // put in the data
        new_node.data = new_data;
 
        // since we are adding at the beginning,
        // prev is always null
        new_node.prev = null;
 
        // link the old list off the new node
        new_node.next = (head_ref);
 
        // change prev of head node to new node
        if ((head_ref) != null)
            (head_ref).prev = new_node;
 
        // move the head to point to the new node
        (head_ref) = new_node;
        return head_ref;
    }
 
    // Function to find product of all the nodes from
    // the doubly linked list that are divisible by K
    function productOfNode(head_ref , K) {
var ptr = head_ref;
var next;
 
        var product = 1;
 
        // Traverse list till last node
        while (ptr != null) {
            next = ptr.next;
 
            // check is node value divided by K
            // if true then add in sum
            if (ptr.data % K == 0)
                product *= ptr.data;
            ptr = next;
        }
 
        // Return product of nodes which
        // are divisible by K
        return product;
    }
 
    // Driver Code
     
        // start with the empty list
var head = null;
 
        // create the doubly linked list
        // 15 16 10 9 6 7 17
        head = push(head, 17);
        head = push(head, 7);
        head = push(head, 6);
        head = push(head, 9);
        head = push(head, 10);
        head = push(head, 16);
        head = push(head, 15);
 
        var K = 3;
 
        var prod = productOfNode(head, K);
 
        document.write("Product = " + prod);
 
// This code contributed by umadevi9616
</script>

Product = 810

Complejidad temporal : O(N), donde N es el número de Nodes.
Espacio Auxiliar: O(1)