Find the Max product Sublist of length K in a Linked list

// Define a class to represent a node in the linked list
class Node {
    constructor(val) {
        this.val = val;   // Value stored in the node
        this.next = null; // Reference to the next node (initially null)
    }
}

// Define a class for the solution
class Solution {
    maxProduct(head, k) {
        const arr = []; // Create an array to store the linked list values
        let curr = head; // Start at the head of the linked list

        // Traverse the linked list and store values in the array
        while (curr !== null) {
            arr.push(curr.val);
            curr = curr.next;
        }

        const n = arr.length; 
        let left = 0; 
        let right = k - 1; 
        let prod = 1;
        let maxProd = 0; 

        // Calculate the initial product of the first 'k' elements
        for (let i = 0; i < k; i++) {
            prod *= arr[i];
        }

        // Update the maximum product if the initial product is greater
        maxProd = Math.max(maxProd, prod);

        // Sliding window approach to find the maximum product
        while (right < n - 1) {
            // Divide by the element going out of the window and multiply by the new element
            prod /= arr[left];
            prod *= arr[right + 1];
            left++; // Move the left pointer
            right++; // Move the right pointer
            // Update the maximum product if a greater product is found
            maxProd = Math.max(maxProd, prod);
        }

        return maxProd; // Return the maximum product
    }
}

// Driver code 
const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

const sol = new Solution();
const k = 3;

// Function Call to find the maximum product of 'k' consecutive elements
console.log(sol.maxProduct(head, k));

<script>
// JavaScript code for the above approach

// Definition of a Node for the linked list
class Node {
    constructor(x) {
        this.val = x; // Value of the node
        this.next = null; // Pointer to the next node
    }
}

// Class to implement the solution
class Solution {
    // Function to find the maximum product of K consecutive nodes
    maxProduct(head, k) {
        let max_prod = 0; // Variable to store the maximum product found
        let prod = 1; // Variable to keep track of the current product
        let count = 0; // Variable to keep track of the number of nodes encountered
        let curr = head; // Pointer to traverse the linked list
        let q = []; // Queue to keep track of the last K values encountered

        // Traverse the linked list
        while (curr !== null) {
            q.push(curr.val); // Push the current node's value to the queue
            count++; // Increment the count of nodes encountered
            prod *= curr.val; // Update the product

            // If the count exceeds K, update the product and count accordingly
            if (count > k) {
                let front = q.shift(); // Remove the first element from the queue
                prod /= front; // Adjust the product
                count--; // Decrement the count
            }

            // If K nodes have been encountered, update the maximum product
            if (count === k) {
                max_prod = Math.max(max_prod, prod); // Update the maximum product if necessary
            }

            curr = curr.next; // Move to the next node
        }
        return max_prod; // Return the maximum product found
    }
}

// Driver code
let head = new Node(1); // Create the first node
head.next = new Node(2); // Add the second node
head.next.next = new Node(3); // Add the third node
head.next.next.next = new Node(4); // Add the fourth node
head.next.next.next.next = new Node(5); // Add the fifth node

let sol = new Solution(); // Create an instance of the solution class
let k = 3; // Set the value of K

// Function call to find the maximum product of K consecutive nodes
document.write(sol.maxProduct(head, k)); // Print the result

// This code is contributed by Susobhan Akhuli
</script>