Print middle level of perfect binary tree without finding height

Iterative Method to find Height of Binary Tree

Last Updated : 21 Jun, 2022

There are two conventions to define the height of a Binary Tree

Number of nodes on the longest path from the root to the deepest node.
Number of edges on the longest path from the root to the deepest node.

In this post, the first convention is followed. For example, the height of the below tree is 3.

Example Tree

The recursive method to find the height of the Binary Tree is discussed here. How to find height without recursion? We can use level order traversal to find height without recursion. The idea is to traverse level by level. Whenever move down to a level, increment height by 1 (height is initialized as 0). Count number of nodes at each level, stop traversing when the count of nodes at the next level is 0.

Following is a detailed algorithm to find level order traversal using a queue.

Create a queue.
Push root into the queue.
height = 0
nodeCount = 0 // Number of nodes in the current level.

// If the number of nodes in the queue is 0, it implies 
// that all the levels of the tree have been parsed. So, 
// return the height. Otherwise count the number of nodes 
// in the current level and push the children of all the 
// nodes in the current level to the queue. 

Loop
    nodeCount = size of queue
    
    // If the number of nodes at this level is 0, return height
    
    if nodeCount is 0
        return Height;
    else
        increase Height

        // Remove nodes of this level and add nodes of 
        // next level
    while (nodeCount > 0)
        push its children to queue
        pop node from front
        decrease nodeCount
       // At this point, queue has nodes of next level

Following is the implementation of the above algorithm.

C++

#include <iostream>
#include <queue>
 
using namespace std;
 
// This approach counts the number of nodes from root to the
// leaf to calculate the height of the tree.
 
// Defining the structure of a Node.
 
class Node {
public:
    int data;
    Node* left;
    Node* right;
};
 
// Helper function to create a newnode.
// Input: Data for the newnode.
// Return: Address of the newly created node.
 
Node* createNode(int data)
{
 
    Node* newnode = new Node();
    newnode->data = data;
    newnode->left = NULL;
    newnode->right = NULL;
 
    return newnode;
}
 
// Function to calculate the height of given Binary Tree.
// Input: Address of the root node of Binary Tree.
// Return: Height of Binary Tree as a integer. This includes
// the number of nodes from root to the leaf.
 
int calculateHeight(Node* root)
{
    queue<Node*> nodesInLevel;
    int height = 0;
    int nodeCount = 0; // Calculate  number of nodes in a level.
    Node* currentNode; // Pointer to store the address of a
                       // node in the current level.
    if (root == NULL) {
        return 0;
    }
    nodesInLevel.push(root);
    while (!nodesInLevel.empty()) {
        // This while loop runs for every level and
        // increases the height by 1 in each iteration. If
        // the queue is empty then it implies that the last
        // level of tree has been parsed.
        height++;
        // Create another while loop which will insert all
        // the child nodes of the current level in the
        // queue.
 
        nodeCount = nodesInLevel.size();
        while (nodeCount--) {
            currentNode = nodesInLevel.front();
 
            // Check if the current nodes has left child and
            // insert it in the queue.
 
            if (currentNode->left != NULL) {
                nodesInLevel.push(currentNode->left);
            }
 
            // Check if the current nodes has right child
            // and insert it in the queue.
            if (currentNode->right != NULL) {
                nodesInLevel.push(currentNode->right);
            }
 
            // Once the children of the current node are
            // inserted. Delete the current node.
 
            nodesInLevel.pop();
        }
    }
    return height;
}
 
// Driver Function.
 
int main()
{
    // Creating a binary tree.
 
    Node* root = NULL;
 
    root = createNode(1);
    root->left = createNode(2);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right = createNode(3);
 
    cout << "The height of the binary tree using iterative "
            "method is: " << calculateHeight(root) << ".";
 
    return 0;
}

Java

// An iterative java program to find height of binary tree
  
import java.util.LinkedList;
import java.util.Queue;
  
// A binary tree node
class Node 
{
    int data;
    Node left, right;
  
    Node(int item) 
    {
        data = item;
        left = right;
    }
}
  
class BinaryTree 
{
    Node root;
  
    // Iterative method to find height of Binary Tree
    int treeHeight(Node node) 
    {
        // Base Case
        if (node == null)
            return 0;
  
        // Create an empty queue for level order traversal
        Queue<Node> q = new LinkedList();
  
        // Enqueue Root and initialize height
        q.add(node);
        int height = 0;
  
        while (1 == 1) 
        {
            // nodeCount (queue size) indicates number of nodes
            // at current level.
            int nodeCount = q.size();
            if (nodeCount == 0)
                return height;
            height++;
  
            // Dequeue all nodes of current level and Enqueue all
            // nodes of next level
            while (nodeCount > 0) 
            {
                Node newnode = q.peek();
                q.remove();
                if (newnode.left != null)
                    q.add(newnode.left);
                if (newnode.right != null)
                    q.add(newnode.right);
                nodeCount--;
            }
        }
    }
  
    // Driver program to test above functions
    public static void main(String args[]) 
    {
        BinaryTree tree = new BinaryTree();
         
        // Let us create a binary tree shown in above diagram
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
        System.out.println("Height of tree is " + tree.treeHeight(tree.root));
    }
}
  
// This code has been contributed by Mayank Jaiswal

Python3

# Program to find height of tree by Iteration Method
 
# A binary tree node
class Node:
     
    # Constructor to create new node
    def __init__(self, data):
        self.data = data 
        self.left = None
        self.right = None
 
# Iterative method to find height of Binary Tree
def treeHeight(root):
     
    # Base Case
    if root is None:
        return 0
     
    # Create a empty queue for level order traversal
    q = []
     
    # Enqueue Root and Initialize Height 
    q.append(root)
    height = 0
 
    while(True):
         
        # nodeCount(queue size) indicates number of nodes
        # at current level
        nodeCount = len(q)
        if nodeCount == 0 :
            return height 
     
        height += 1
 
        # Dequeue all nodes of current level and Enqueue
        # all nodes of next level
        while(nodeCount > 0):
            node = q[0]
            q.pop(0)
            if node.left is not None:
                q.append(node.left)
            if node.right is not None:
                q.append(node.right)
 
            nodeCount -= 1
 
 
# Driver program to test above function
# Let us create binary tree shown in above diagram
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
 
print ("Height of tree is", treeHeight(root))
 
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

C#

// An iterative C# program to
// find height of binary tree
using System;
using System.Collections.Generic; 
 
// A binary tree node
class Node 
{
    public int data;
    public Node left, right;
 
    public Node(int item) 
    {
        data = item;
        left = right;
    }
}
 
public class BinaryTree 
{
    Node root;
 
    // Iterative method to find
    // height of Binary Tree
    int treeHeight(Node node) 
    {
        // Base Case
        if (node == null)
            return 0;
 
        // Create an empty queue 
        // for level order traversal
        Queue<Node> q = new Queue<Node>();
 
        // Enqueue Root and initialize height
        q.Enqueue(node);
        int height = 0;
 
        while (1 == 1) 
        {
            // nodeCount (queue size) indicates
            // number of nodes at current level.
            int nodeCount = q.Count;
            if (nodeCount == 0)
                return height;
            height++;
 
            // Dequeue all nodes of current
            // level and Enqueue all
            // nodes of next level
            while (nodeCount > 0) 
            {
                Node newnode = q.Peek();
                q.Dequeue();
                if (newnode.left != null)
                    q.Enqueue(newnode.left);
                if (newnode.right != null)
                    q.Enqueue(newnode.right);
                nodeCount--;
            }
        }
    }
 
    // Driver code
    public static void Main(String []args) 
    {
        BinaryTree tree = new BinaryTree();
         
        // Let us create a binary 
        // tree shown in above diagram
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
        Console.WriteLine("Height of tree is " + 
                        tree.treeHeight(tree.root));
    }
}
 
// This code has been contributed by 29AjayKumar

Javascript

<script>
// An iterative javascript program to find height of binary tree
 
// A binary tree node
class Node
{
    constructor(item)
    {
        this.data = item;
        this.left = this.right=null;
    }
}
 
let root;
 
// Iterative method to find height of Binary Tree
function treeHeight(node)
{
 
    // Base Case
        if (node == null)
            return 0;
   
        // Create an empty queue for level order traversal
        let q = [];
   
        // Enqueue Root and initialize height
        q.push(node);
        let height = 0;
   
        while (1 == 1)
        {
            // nodeCount (queue size) indicates number of nodes
            // at current level.
            let nodeCount = q.length;
            if (nodeCount == 0)
                return height;
            height++;
   
            // Dequeue all nodes of current level and Enqueue all
            // nodes of next level
            while (nodeCount > 0)
            {
                let newnode = q.shift();
                if (newnode.left != null)
                    q.push(newnode.left);
                if (newnode.right != null)
                    q.push(newnode.right);
                nodeCount--;
            }
        }
}
 
// Driver program to test above functions
// Let us create a binary tree shown in above diagram
root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
document.write("Height of tree is " + treeHeight(root));
 
// This code is contributed by rag2127
</script>

Output

The height of the binary tree using iterative method is: 3.

Time Complexity: O(n) where n is the number of nodes in a given binary tree.
Space Complexity: O(n) where n is the number of nodes in a given binary tree.

Print middle level of perfect binary tree without finding height

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Iterative method to find ancestors of a given binary tree

Given a binary tree, print all the ancestors of a particular key existing in the tree without using recursion.Here we will be discussing the implementation for the above problem. Examples: Input : 1 / \ 2 7 / \ / \ 3 5 8 9 / \ / 4 6 10 Key = 6 Output : 5 2 1 Ancestors of 6 are 5, 2 and 1. The idea i

Iterative program to count leaf nodes in a Binary Tree

Given a Binary Tree, the task is to count leaves in it. A node is a leaf node if both left and right child nodes of it are NULL. Example: Input: Output: 3Explanation: Three leaf nodes are 3, 4 and 5 as both of their left and right child is NULL.Input: Output: 3Explanation: Three leaf nodes are 4, 6

Height of binary tree considering even level leaves only

Find the height of the binary tree given that only the nodes on the even levels are considered valid leaf nodes. The height of a binary tree is the number of edges between the tree's root and its furthest leaf. But what if we bring a twist and change the definition of a leaf node? Let us define a va

Find sum of all left leaves in a given Binary Tree

Given a Binary Tree, find the sum of all left leaves in it. For example, sum of all left leaves in below Binary Tree is 5+1=6. Recommended PracticeSum of Left Leaf NodesTry It! The idea is to traverse the tree, starting from root. For every node, check if its left subtree is a leaf. If it is, then a

Print middle level of perfect binary tree without finding height

Given a perfect binary tree, print nodes of middle level without computing its height. A perfect binary tree is a binary tree in which all interior nodes have two children and all leaves have the same depth or same level. Output : 4 5 6 7 The idea is similar to method 2 of finding middle of singly l

Iterative searching in Binary Search Tree

Given a Binary Search Tree and a key, the task is to find if the node with a value key is present in the BST or not. Example: Input: Root of the below BST Output: TrueExplanation: 8 is present in the BST as right child of rootInput: Root of the below BST Output: FalseExplanation: 14 is not present i

Find mirror of a given node in Binary tree

Given a Binary tree, the problem is to find the mirror of a given node. The mirror of a node is a node which exists at the mirror position of the node in opposite subtree at the root. Examples: In above tree- Node 2 and 3 are mirror nodes Node 4 and 6 are mirror nodes. Recommended PracticeMirror of

Height and Depth of a node in a Binary Tree

Given a Binary Tree consisting of n nodes and a integer k, the task is to find the depth and height of the node with value k in the Binary Tree. Note: The depth of a node is the number of edges present in path from the root node of a tree to that node. The height of a node is the maximum number of e

Introduction to Height Balanced Binary Tree

A height-balanced binary tree is defined as a binary tree in which the height of the left and the right subtree of any node differ by not more than 1. AVL tree, red-black tree are examples of height-balanced trees. Conditions for Height-Balanced Binary Tree: Following are the conditions for a height

Iterative approach to check if a Binary Tree is BST or not

Given a Binary Tree, the task is to check if the given binary tree is a Binary Search Tree or not. If found to be true, then print "YES". Otherwise, print "NO". Examples: Input: 9 / \ 6 10 / \ \ 4 7 11 / \ \ 3 5 8 Output: YES Explanation: Since the left subtree of each node of the tree consists of s