Producto de los Nodes de una lista enlazada simple

Dada una lista enlazada simple. La tarea es encontrar el producto de todos los Nodes de la lista enlazada dada.
Ejemplos : 
 

Input : List = 7->6->8->4->1
Output : Product = 1344
Product of nodes: 7 * 6 * 8 * 4 * 1 = 1344

Input : List = 1->7->3->9->11->5
Output : Product = 10395

Algoritmo : 
 

1. Inicialice un puntero ptr con el encabezado de la lista enlazada y una variable de producto con 1.
2. Comience a recorrer la lista vinculada utilizando un bucle hasta que se atraviesen todos los Nodes.
3. Multiplique el valor del Node actual por el producto, es decir , producto *= ptr -> datos .
4. Incremente el puntero al siguiente Node de la lista enlazada, es decir , ptr = ptr ->next .
5. Repita los dos pasos anteriores hasta llegar al final de la lista enlazada.
6. Finalmente, devuelva el producto.

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

// C++ implementation to find the product of
// nodes of the Linked List
 
#include <iostream>
using namespace std;
 
// A Linked list node
struct Node {
    int data;
    struct Node* next;
};
 
// Function to insert a node at the
// beginning of the linked list
void push(struct Node** head_ref, int new_data)
{
    /* allocate node */
    struct Node* new_node = new Node;
 
    /* put in the data */
    new_node->data = new_data;
 
    /* link the old list to the new node */
    new_node->next = (*head_ref);
 
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
// Function to find the product of
// nodes of the given linked list
int productOfNodes(struct Node* head)
{
    // Pointer to traverse the list
    struct Node* ptr = head;
 
    int product = 1; // Variable to store product
 
    // Traverse the list and
    // calculate the product
    while (ptr != NULL) {
 
        product *= ptr->data;
        ptr = ptr->next;
    }
 
    // Return the product
    return product;
}
 
// Driver Code
int main()
{
    struct Node* head = NULL;
 
    // create linked list 7->6->8->4->1
    push(&head, 7);
    push(&head, 6);
    push(&head, 8);
    push(&head, 4);
    push(&head, 1);
 
    cout << "Product = " << productOfNodes(head);
 
    return 0;
}

// Java implementation to find the product of
// nodes of the Linked List
class GFG
{
 
// A Linked list node
static class Node
{
    int data;
    Node next;
};
 
// Function to insert a node at the
// beginning of the 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;
 
    // link the old list to the new node /
    new_node.next = (head_ref);
 
    // move the head to point to the new node /
    (head_ref) = new_node;
    return head_ref;
}
 
// Function to find the product of
// nodes of the given linked list
static int productOfNodes( Node head)
{
    // Pointer to traverse the list
    Node ptr = head;
 
    int product = 1; // Variable to store product
 
    // Traverse the list and
    // calculate the product
    while (ptr != null)
    {
 
        product *= ptr.data;
        ptr = ptr.next;
    }
 
    // Return the product
    return product;
}
 
// Driver Code
public static void main(String args[])
{
    Node head = null;
 
    // create linked list 7.6.8.4.1
    head = push(head, 7);
    head = push(head, 6);
    head = push(head, 8);
    head = push(head, 4);
    head = push(head, 1);
 
    System.out.println("Product = " + productOfNodes(head));
}
}
 
// This code is contributed by Arnab Kundu

# Python3 implementation to find the product of
# nodes of the Linked List
import math
 
# A linked List node
class Node:
    def __init__(self,data):
        self.data = data
        self.next = None
 
# Function to insert a node at the
# beginning of the linked list
def push(head,data):
    if not head:
 
        # Return new node
        return Node(data)
     
    # allocate node
    new_node = Node(data)
     
    # link the old list to the new node
    new_node.next = head
     
    # move the head to point to the new node
    head = new_node
    return head
 
# Function to find the product of
# nodes of the given linked list
def productOfNodes(head):
     
    # Pointer to traverse the list
    ptr = head
    product = 1 # Variable to store product
 
    # Traverse the list and
    # calculate the product
    while(ptr):
        product *= ptr.data
        ptr = ptr.next
         
    # Return the product    
    return product
 
# Driver Code
if __name__=='__main__':
    head = None
 
    # create linked list 7->6->8->4->1
    head = push(head,7)
    head = push(head,6)
    head = push(head,8)
    head = push(head,4)
    head = push(head,1)
    print("Product = {}".format(productOfNodes(head)))
 
# This Code is Contributed By Vikash Kumar 37

// C# implementation to find the product of
// nodes of the Linked List
using System;
 
class GFG
{
 
// A Linked list node
public class Node
{
    public int data;
    public Node next;
};
 
// Function to insert a node at the
// beginning of the 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;
 
    // link the old list to the new node /
    new_node.next = (head_ref);
 
    // move the head to point to the new node /
    (head_ref) = new_node;
    return head_ref;
}
 
// Function to find the product of
// nodes of the given linked list
static int productOfNodes( Node head)
{
    // Pointer to traverse the list
    Node ptr = head;
 
    int product = 1; // Variable to store product
 
    // Traverse the list and
    // calculate the product
    while (ptr != null)
    {
        product *= ptr.data;
        ptr = ptr.next;
    }
 
    // Return the product
    return product;
}
 
// Driver Code
public static void Main(String []args)
{
    Node head = null;
 
    // create linked list 7.6.8.4.1
    head = push(head, 7);
    head = push(head, 6);
    head = push(head, 8);
    head = push(head, 4);
    head = push(head, 1);
 
    Console.WriteLine("Product = " +
                       productOfNodes(head));
}
}
 
// This code is contributed by Rajput-Ji

<script>
// javascript implementation to find the product of
// nodes of the Linked List    
// A Linked list node
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}
 
    // Function to insert a node at the
    // beginning of the linked list
    function push(head_ref , new_data) {
        // allocate node /
var new_node = new Node();
 
        // put in the data /
        new_node.data = new_data;
 
        // link the old list to the new node /
        new_node.next = (head_ref);
 
        // move the head to point to the new node /
        (head_ref) = new_node;
        return head_ref;
    }
 
    // Function to find the product of
    // nodes of the given linked list
    function productOfNodes(head) {
        // Pointer to traverse the list
var ptr = head;
 
        var product = 1; // Variable to store product
 
        // Traverse the list and
        // calculate the product
        while (ptr != null) {
 
            product *= ptr.data;
            ptr = ptr.next;
        }
 
        // Return the product
        return product;
    }
 
    // Driver Code
     
var head = null;
 
        // create linked list 7.6.8.4.1
        head = push(head, 7);
        head = push(head, 6);
        head = push(head, 8);
        head = push(head, 4);
        head = push(head, 1);
 
        document.write("Product = " + productOfNodes(head));
 
// This code contributed by aashish1995
</script>

Product = 1344

Complejidad de tiempo : O(N), donde N es el número de Nodes en la lista enlazada.
Espacio Auxiliar: O(1)