Find the maximum sum on the basis of the given Binary String

// JavaScript code for the above approach

class MaxHeap {
    constructor() {
        this.values = [];
    }

    // index of the parent node
    parent(index) {
        return Math.floor((index - 1) / 2);
    }

    // index of the left child node
    leftChild(index) {
        return (index * 2) + 1;
    }

    // index of the right child node
    rightChild(index) {
        return (index * 2) + 2;
    }

    // returns true if index is of a node that has no children
    isLeaf(index) {
        return (
            index >= Math.floor(this.values.length / 2) && index <= this.values.length - 1
        )
    }

    // swap using ES6 destructuring
    swap(index1, index2) {
        [this.values[index1], this.values[index2]] = [this.values[index2], this.values[index1]];
    }


    heapifyDown(index) {

        // if the node at index has children
        if (!this.isLeaf(index)) {

            // get indices of children
            let leftChildIndex = this.leftChild(index),
                rightChildIndex = this.rightChild(index),

                // start out largest index at parent index
                largestIndex = index;

            // if the left child > parent
            if (this.values[leftChildIndex] > this.values[largestIndex]) {
                // reassign largest index to left child index
                largestIndex = leftChildIndex;
            }

            // if the right child > element at largest index (either parent or left child)
            if (this.values[rightChildIndex] >= this.values[largestIndex]) {
                // reassign largest index to right child index
                largestIndex = rightChildIndex;
            }

            // if the largest index is not the parent index
            if (largestIndex !== index) {
                // swap
                this.swap(index, largestIndex);
                // recursively move down the heap
                this.heapifyDown(largestIndex);
            }
        }
    }

    heapifyUp(index) {
        let currentIndex = index,
            parentIndex = this.parent(currentIndex);

        // while we haven't reached the root node and the current element is greater than its parent node
        while (currentIndex > 0 && this.values[currentIndex] > this.values[parentIndex]) {
            // swap
            this.swap(currentIndex, parentIndex);
            // move up the binary heap
            currentIndex = parentIndex;
            parentIndex = this.parent(parentIndex);
        }
    }

    add(element) {
        // add element to the end of the heap
        this.values.push(element);
        // move element up until it's in the correct position
        this.heapifyUp(this.values.length - 1);
    }

    // returns value of max without removing
    peek() {
        return this.values[0];
    }

    // removes and returns max element
    extractMax() {
        if (this.values.length < 1) return 'heap is empty';

        // get max and last element
        const max = this.values[0];
        const end = this.values.pop();
        // reassign first element to the last element
        this.values[0] = end;
        // heapify down until element is back in its correct position
        this.heapifyDown(0);

        // return the max
        return max;
    }

    buildHeap(array) {
        this.values = array;
        // since leaves start at floor(nodes / 2) index, we work from the leaves up the heap
        for(let i = Math.floor(this.values.length / 2); i >= 0; i--){
            this.heapifyDown(i);
        }
    }

    /*print() {
        let i = 0;
        while (!this.isLeaf(i)) {
            console.log("PARENT:", this.values[i]);
            console.log("LEFT CHILD:", this.values[this.leftChild(i)]);
            console.log("RIGHT CHILD:", this.values[this.rightChild(i)]);
            i++;
        }      
    }*/
}

// Function to find the maximum profit
function findmax_profit(profit, str, n)
{
    // Initialize a priority queue to implement the max heap
    let pq = new MaxHeap();
    let res = 0;

    // Loop to find the maximum possible sum
    for (let i = 0; i < n; i++) {

        // Insert the array value in priority queue
        pq.add(profit[i]);

        // If the string value is '1'
        // pop the highest possible value
        // from priority queue
        if (str[i] == '1') {
            res += pq.peek();
            pq.extractMax();
        }
    }

    // Return the res
    return res;
}

// Driver code
    // Test case 1
    let profit = [ 12, 10, 5, 8, 9, 6 ];
    let str = "001110";
    let N = profit.length;
    console.log(findmax_profit(profit, str, N));

    // Test case 2
    let profit1 = [ 10, 5, 8, 9, 6 ];
    let str1 = "01110";
    N = profit.length;
    console.log(findmax_profit(profit1, str1, N));

    // Test case 3
    let profit2 = [ 20, 10, 9, 30, 20, 9 ];
    let str2 = "011011";
    N = profit.length;
    console.log(findmax_profit(profit2, str2, N));

// This code is contributed by poojaagarwal2.