Various operations on Fibonacci nodes in a Singly Linked list

<script>
// javascript implementation to perform the
// operations on Fibonacci nodes
// of a Singly Linked list     
var hashmap = new Set();

    // Node of the singly linked list
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}
    // Function to insert a node at the beginning
    // of the singly Linked List
    function push(head_ref , new_data) {
        // Allocate a new node
var new_node = new Node();

        // Insert the data
        new_node.data = new_data;
        new_node.next = head_ref;

        // Move the head to point the new node
        head_ref = new_node;
        return head_ref;
    }

    // Function to delete a node in a SLL
    // head_ref -. pointer to head node pointer.
    // del -. pointer to node to be deleted
    function deleteNode(head_ref,  del) {
        // Base case
var temp = head_ref;

        if (head_ref == null || del == null)
            return null;

        // If the node to be deleted is
        // the head node
        if (head_ref == del)
            head_ref = del.next;

        // Traverse list till not found
        // delete node
        while (temp.next != del) {
            temp = temp.next;
        }

        // Copy address of node
        temp.next = del.next;

        // Finally, free the memory
        // occupied by del
        del = null;

        return head_ref;
    }

    // Function that returns the largest element
    // from the linked list.
    function largestElement(head_ref) {
        // Declare a max variable and
        // initialize it with Number.MIN_VALUE value.
        // Number.MIN_VALUE is integer type and
        // its value is -32767 or less.
        var max = Number.MIN_VALUE;

var head = head_ref;

        // Loop to iterate the linked list
        while (head != null) {

            // If max is less than head.data then
            // assign value of head.data to max
            // otherwise node point to next node.
            if (max < head.data)
                max = head.data;

            head = head.next;
        }
        return max;
    }

    // Function to create a hash table
    // to check Fibonacci nodes
    function createHash(maxElement) {
        // Insert the first two
        // elements in the hash
        var prev = 0, curr = 1;
        hashmap.add(prev);
        hashmap.add(curr);

        // Add the elements until the max element
        // by using the previous two numbers
        while (curr <= maxElement) {
            var temp = curr + prev;
            hashmap.add(temp);
            prev = curr;
            curr = temp;
        }
    }

    // Function to print the Fibonacci
    // nodes in a linked list
    function printFibonacci(head_ref) {

        var count = 0;
var ptr = head_ref;

        document.write("Fibonacci nodes = ");

        while (ptr != null) {

            // If current node is Fibonacci
            if (hashmap.has(ptr.data)) {

                // Update count
                document.write(ptr.data + " ");
            }

            ptr = ptr.next;
        }

        document.write("<br/>");
        return 0;
    }

    // Function to find the count of Fibonacci
    // nodes in a linked list
    function countFibonacci(head_ref) {

        var count = 0;
var ptr = head_ref;

        while (ptr != null) {

            // If current node is Fibonacci
            if (hashmap.has(ptr.data)) {

                // Update count
                count++;
            }

            ptr = ptr.next;
        }

        return count;
    }

    // Function to find maximum and minimum
    // fibonacci nodes in a linked list
    function minmaxFibonacciNodes(head_ref) {
        // Find the largest node value
        // in Singly Linked List
        var maxEle = largestElement(head_ref);

        // Creating a set containing
        // all the Fibonacci nodes
        // upto the maximum data value
        // in the Singly Linked List
        // HashSet<Integer> hash;
        // createHash(hash, maxEle);

        var minimum = Number.MAX_VALUE;
        var maximum = Number.MIN_VALUE;
var ptr = head_ref;

        while (ptr != null) {

            // If current node is fibonacci
            if (hashmap.has(ptr.data)) {

                // Update minimum
                minimum = Math.min(minimum, ptr.data);

                // Update maximum
                maximum = Math.max(maximum, ptr.data);
            }
            ptr = ptr.next;
        }

        document.write("Minimum Fibonacci node: " + minimum + "<br/>");
        document.write("Maximum Fibonacci node: " + maximum + "<br/>");
    }

    // Function to delete all the
    // fibonacci nodes from the
    // singly linked list
    function deleteFibonacciNodes(head_ref) {

var ptr = head_ref;
var next;

        // Iterating through the linked list
        while (ptr != null) {
            next = ptr.next;

            // If the node's data is fibonacci,
            // delete node 'ptr'
            if (hashmap.has(ptr.data))
                deleteNode(head_ref, ptr);

            ptr = next;
        }
        return head_ref;
    }

    // Function to print nodes in a
    // given singly linked list
    function printList(head) {
        while (head != null) {
            document.write(head.data + " ");
            head = head.next;
        }
    }

    function operations(head) {
        // Find the largest node value
        // in Singly Linked List
        var maxEle = largestElement(head);

        // Creating a set containing
        // all Fibonacci nodes
        // upto the maximum data value
        // in the Singly Linked List
        createHash(maxEle);

        // Print all Fibonacci nodes
        printFibonacci(head);

        // Count of Fibonacci nodes
        document.write("Count of Fibonacci nodes = " + countFibonacci(head) + "<br/>");

        // Minimum and maximum Fibonacci nodes
        minmaxFibonacciNodes(head);

        // Delete Fibonacci nodes
        head = deleteFibonacciNodes(head);

        document.write("List after deletion: ");
        printList(head);
    }

    // Driver program
    
        // Start with the empty list
var head = null;

        // Create the linked list
        // 15.16.8.6.13
        head = push(head, 13);
        head = push(head, 6);
        head = push(head, 8);
        head = push(head, 16);
        head = push(head, 15);

        operations(head);


// This code contributed by gauravrajput1 
</script>