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:
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
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));
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));
Time Complexity: O((log N)2)
Space Complexity: O(log n)
Similar Reads
Print the nodes having exactly one child in a Binary tree using JavaScript Given a binary tree, our task is to return the number of nodes in the Binary tree that have at least one child otherwise return “-1†if no such node exists. Examples: Input: 1 / \ 2 3 / \ 4 5 / 6Output: 3Explanation:There are three nodes in the Binary tree that have at least one child that are 1,2,4
4 min read
Count the number of Nodes in a Binary Tree in Constant Space Given a binary tree having N nodes, count the number of nodes using constant O(1) space. This can be done by simple traversals like- Preorder, InOrder, PostOrder, and LevelOrder but these traversals require an extra space which is equal to the height of the tree. Examples: Input: Output: 5Explanatio
10 min read
Convert a Binary Tree to a Binary Search Tree using JavaScript Given a Binary Tree, the task is to convert it to a Binary Search Tree. The conversion must be done in such a way that it keeps the original structure of the Binary Tree. Example: To demonstrate the conversion of the Binary Tree to the Binary Search Tree.Input: 10 / \ 2 7 / \ 8 4Output: 8 / \ 4 10 /
2 min read
Find the Preorder Successor of a Given Node in a Binary Tree using JavaScript The Preorder successor of a given node is a node that occurs after the given node in the preorder traversal of the binary tree. The preorder traversal is a traversal in which the root node is visited first, then the left child, and then the right child. Example: The pre-order successor of a binary t
2 min read
Check Symmetrical Binary Tree using JavaScript Given a binary tree, our task is to check whether it is Symmetrical Binary tree. In other words, we need to check whether the binary tree is a mirror of itself. Example: Input: 11 / \ 12 12 / \ / \ 13 14 14 13Output: True Input: 11 / \ 12 12 \ \ 13 13Output: FalseBelow are the approaches to check Sy
3 min read