Count the Number of Nodes in a Complete Binary tree using JavaScript

Last Updated : 01 Jul, 2024

We need to count the number of the nodes in the complete binary tree using JavaScript. The complete binary tree is a binary tree in which every level then except possibly the last, is completely filled and all the nodes are as far left as possible.

There are several approaches for counting the number of nodes in a complete Binary tree using JavaScript which are as follows:

Table of Content

Using Recursion
Using queue
Using while loop

Using Recursion

In recursive approach, we can traverse the entire tree recursively. For the each node, we count the nodes itself plus the number of the nodes in its left subtree and the number of the nodes in its the right subtree.

Example: This illustrates a binary tree using TreeNode class instances and counts the total number of nodes in the tree using a recursive function `countNodes`, returning the count.

JavaScript

class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

function countNodes(root) {
    if (root === null) {
        return 0;
    }
    return 1 + countNodes(root.left) + countNodes(root.right);
}

// Example usage
let root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right.left = new TreeNode(6);

console.log(countNodes(root)); // Output: 6

Output

Time Complexity: O(N)

Space Complexity: O(H)

Using queue

In this approach, we use the queue to traverse the tree level by the level. We can count the each node as we dequeue it.

Example: This illustrates a binary tree using TreeNode instances, then employs an iterative approach with a queue to count all nodes in the tree, returning the total count.

JavaScript

class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
} 

// Example usage
let root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right.left = new TreeNode(6);

function countNodesIterative(root) {
    if (root === null) {
        return 0;
    }

    let count = 0;
    let queue = [root];

    while (queue.length > 0) {
        let node = queue.shift();
        count++;

        if (node.left !== null) {
            queue.push(node.left);
        }
        if (node.right !== null) {
            queue.push(node.right);
        }
    }

    return count;
}

// Example usage
console.log(countNodesIterative(root));

Output

Time Complexity: O(N)

Space Complexity: O(N)

Using while loop

In this approach, we can take the advantages of the properties of the complete binary tree. If the left and right subtrees of the node have the same height then the left subtree is the perfect binary tree. We can directly calculate the number of the nodes in the left subtree. If the heights are different, the right subtree is the perfect binary tree. This approach can reduces the number of the nodes we need to traverse.

Example: This illustrates the total number of nodes in a binary tree efficiently by leveraging the concept of perfect binary trees and recursively determining the depth of each subtree.

JavaScript

class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

// Example usage
let root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right.left = new TreeNode(6);

function fun(root) {
    if (root === null) {
        return 0;
    }

    let leftDepth = getDepth(root.left);
    let rightDepth = getDepth(root.right);

    if (leftDepth === rightDepth) {
        // Left subtree is a perfect binary tree
        return (1 << leftDepth) + fun(root.right);
    } else {
        // Right subtree is a perfect binary tree
        return (1 << rightDepth) + fun(root.left);
    }
}

function getDepth(node) {
    let depth = 0;
    while (node !== null) {
        depth++;
        node = node.left;
    }
    return depth;
}

// Example usage
console.log(fun(root));

Output

Time Complexity: O((log N)²)

Space Complexity: O(log n)

Count the Number of Nodes in a Complete Binary tree using JavaScript

seepanarajvskq

Improve

Article Tags :

Count the Number of Nodes in a Complete Binary tree using JavaScript

Using Recursion

Using queue

Using while loop

Similar Reads

Thank You!

What kind of Experience do you want to share?