Binary Tree

Last Updated : 30 Jul 2026

A Binary Tree is a tree data structure in which each node has at most two child nodes. These child nodes are referred to as the left child and the right child.

In this chapter, you will learn about the Binary Tree, its structure, characteristics, and node representation, and implementation.

What is a Binary Tree?

A Binary Tree is a non-linear hierarchical data structure in which each node can have a maximum of two children. These children are known as the left child and the right child.

The term binary means two, indicating that each node can have zero, one, or two child nodes. A node with no children is called a leaf node, while a node with one or more children is called an internal node.

Binary trees are widely used in computer science for representing hierarchical data and form the basis of many other data structures, such as Binary Search Trees (BSTs), Heaps, and Expression Trees.

Characteristics of a Binary Tree

A binary tree has the following characteristics:

It consists of a finite number of nodes connected by edges.
Each node has at most two child nodes.
The two child nodes are referred to as the left child and the right child.
A node may have zero, one, or two children.
The topmost node is called the root.
Nodes without children are called leaf nodes.
Every subtree of a binary tree is itself a binary tree.

Example of a Binary Tree

The following figure illustrates a binary tree in which every node has at most two child nodes.

In the above binary tree, each node has at most one left child and one right child. For example, the root node has two children, while some nodes have only one child or no children.

The leaf nodes do not have any children. Therefore, their left and right child references are NULL.

Node Representation of a Binary Tree

A binary tree node contains three components:

Data: It stores the value or information of the node.
Left Pointer: It stores the address of the left child.
Right Pointer: It stores the address of the right child.

The following figure shows the logical representation of a binary tree node.

In the node representation, the left pointer points to the left child, and the right pointer points to the right child. If a child does not exist, the corresponding pointer contains NULL. This representation enables traversal and manipulation of the binary tree.

Properties of Binary Tree

At each level of i, the maximum number of nodes is 2ⁱ.
The height of the tree is defined as the longest path from the root node to the leaf node. The tree which is shown above has a height equal to 3. Therefore, the maximum number of nodes at height 3 is equal to (1+2+4+8) = 15. In general, the maximum number of nodes possible at height h is (2⁰ + 2¹ + 2²+….2^h) = 2^h+1 -1.
The minimum number of nodes possible at height h is equal to h+1.
If the number of nodes is minimum, then the height of the tree would be maximum. Conversely, if the number of nodes is maximum, then the height of the tree would be minimum.

To read more Properties of Binary Tree

If there are 'n' number of nodes in the binary tree, then

The minimum height can be computed as:

As we know that,

n = 2^h+1 -1

n+1 = 2^h+1

Taking log on both the sides,

log₂(n+1) = log2(2^h+1)

log₂(n+1) = h+1

h = log₂(n+1) - 1

The maximum height can be computed as:

As we know that,

n = h+1

h= n-1

Types of Binary Tree

There are the following four types of Binary tree:

Full or Proper or Strict Binary Tree
Complete Binary Tree
Perfect Binary Tree
Degenerate Binary Tree
Balanced Binary Tree

1. Full or Strict Binary Tree

The full binary tree is also known as a proper or strict binary tree. The tree can only be considered as the full binary tree if each node must contain either 0 or 2 children. The full binary tree can also be defined as the tree in which each node must contain 2 children except the leaf nodes.

To read more Full Binary Tree

Example of Full Binary Tree

In the above tree, we can observe that each node is either containing zero or two children; therefore, it is a Full Binary tree.

Properties of Full Binary Tree

The number of leaf nodes is equal to the number of internal nodes plus 1. In the above example, the number of internal nodes is 5; therefore, the number of leaf nodes is equal to 6.
The maximum number of nodes is the same as the number of nodes in the binary tree, i.e., 2^h+1 -1.
The minimum number of nodes in the full binary tree is 2*h-1.
The minimum height of the full binary tree is log₂(n+1) - 1.
The maximum height of the full binary tree can be computed as:

n= 2*h - 1

n+1 = 2*h

h = n+1/2

2. Complete Binary Tree

The complete binary tree is a tree in which all the nodes are completely filled except the last level. In the last level, all the nodes must be as left as possible. In a complete binary tree, the nodes should be added from the left.

To read more Complete Binary Tree

Example of Complete Binary Tree

The above tree is a complete binary tree because all the nodes are completely filled, and all the nodes in the last level are added at the left first.

Properties of Complete Binary Tree

The maximum number of nodes in complete binary tree is 2^h+1 - 1.
The minimum number of nodes in complete binary tree is 2^h.
The minimum height of a complete binary tree is log₂(n+1) - 1.
The maximum height of a complete binary tree is ⌊log₂(n)⌋.

3. Perfect Binary Tree

A tree is a perfect binary tree if all the internal nodes have 2 children, and all the leaf nodes are at the same level.

To read more Perfect Binary Tree

Example of Perfect Binary Tree

Let's look at a simple example of a perfect binary tree.

The below tree is not a perfect binary tree because all the leaf nodes are not at the same level.

Note: All the perfect binary trees are the complete binary trees as well as the full binary tree, but vice versa is not true, i.e., all complete binary trees and full binary trees are the perfect binary trees.

4. Degenerate Binary Tree

The degenerate binary tree is a tree in which all the internal nodes have only one child.

Example of Degenerate Binary Tree

The above tree is a degenerate binary tree because all the nodes have only one child. It is also known as a right-skewed tree as all the nodes have a right child only.

The above tree is also a degenerate binary tree because all the nodes have only one child. It is also known as a left-skewed tree as all the nodes have a left child only.

5. Balanced Binary Tree

The balanced binary tree is a tree in which both the left and right trees differ by at most 1. For example, AVL and Red-Black trees are balanced binary tree.

Example of Balanced Binary Tree

The above tree is a balanced binary tree because the difference between the left subtree and right subtree is zero.

The above tree is not a balanced binary tree because the difference between the left subtree and the right subtree is greater than 1.

Binary Tree Implementation

A Binary tree is implemented with the help of pointers. The first node in the tree is represented by the root pointer. Each node in the tree consists of three parts, i.e., data, left pointer and right pointer. To create a binary tree, we first need to create the node. We will create the node of user-defined as shown below:

struct node  
{  
   int data,  
   struct node *left, *right;  
}  

In the above structure, data is the value, left pointer contains the address of the left node, and right pointer contains the address of the right node.

Implementation of Binary Tree in Python/ Java/ C++/ C/ C#

Python

# Node class representing each node in the binary search tree
class Node:
    def __init__(self, key):
        self.keyNode = key
        self.leftNode = None
        self.rightNode = None
# BinaryTree class implementing all BST operations
class BinaryTree:
    def __init__(self):
        self.rootNode = None
    # Function to insert a new node into the BST
    def insert(self, keyNode):
        self.rootNode = self._insertRec(self.rootNode, keyNode)
    def _insertRec(self, rootNode, keyNode):
        # If tree is empty, return a new node
        if rootNode is None:
            return Node(keyNode)
        # Recur down the tree
        if keyNode < rootNode.keyNode:
            rootNode.leftNode = self._insertRec(rootNode.leftNode, keyNode)
        elif keyNode > rootNode.keyNode:
            rootNode.rightNode = self._insertRec(rootNode.rightNode, keyNode)
        return rootNode
    # Inorder traversal (Left → Root → Right)
    def inorderTraverse(self):
        self._inorder(self.rootNode)
        print()
    def _inorder(self, rootNode):
        if rootNode:
            self._inorder(rootNode.leftNode)
            print(rootNode.keyNode, end=" ")
            self._inorder(rootNode.rightNode)
    # Preorder traversal (Root → Left → Right)
    def preorderTraverse(self):
        self._preorder(self.rootNode)
        print()
    def _preorder(self, rootNode):
        if rootNode:
            print(rootNode.keyNode, end=" ")
            self._preorder(rootNode.leftNode)
            self._preorder(rootNode.rightNode)
    # Postorder traversal (Left → Right → Root)
    def postorderTraverse(self):
        self._postorder(self.rootNode)
        print()
    def _postorder(self, rootNode):
        if rootNode:
            self._postorder(rootNode.leftNode)
            self._postorder(rootNode.rightNode)
            print(rootNode.keyNode, end=" ")
    # Search for an element
    def searchElement(self, keyNode):
        return self._searchRec(self.rootNode, keyNode)
    def _searchRec(self, rootNode, keyNode):
        if rootNode is None:
            return False
        if rootNode.keyNode == keyNode:
            return True
        elif keyNode < rootNode.keyNode:
            return self._searchRec(rootNode.leftNode, keyNode)
        else:
            return self._searchRec(rootNode.rightNode, keyNode)
    # Calculate minimum and maximum values
    def calculateMinValue(self):
        current = self.rootNode
        if not current:
            raise Exception("Tree is empty")
        while current.leftNode:
            current = current.leftNode
        return current.keyNode
    def calculateMaxValue(self):
        current = self.rootNode
        if not current:
            raise Exception("Tree is empty")
        while current.rightNode:
            current = current.rightNode
        return current.keyNode
# Main section
if __name__ == "__main__":
    tree = BinaryTree()
    for val in [12, 72, 24, 60, 36, 48, 84]:
        tree.insert(val)
    print("Inorder Traversal (Left → Root → Right):")
    tree.inorderTraverse()
    print("Preorder Traversal (Root → Left → Right):")
    tree.preorderTraverse()
    print("Postorder Traversal (Left → Right → Root):")
    tree.postorderTraverse()
    searchKey = 40
    if tree.searchElement(searchKey):
        print(f"Key {searchKey} found in the tree.")
    else:
        print(f"Key {searchKey} not found in the tree.")
    print("Minimum value in the tree:", tree.calculateMinValue())
    print("Maximum value in the tree:", tree.calculateMaxValue())

Execute Now

Java

// Node Class
class Node {
    int keyNode;
    Node leftNode, rightNode;
    // Constructor to initialize the node with a value
    public Node(int item) {
        keyNode = item;
        leftNode = rightNode = null;
    }
}
// BinaryTree Class
class BinaryTree {
    Node rootNode;
    // Constructor to initialize an empty tree
    public BinaryTree() {
        rootNode = null;
    }
    // Method to insert a new node with the given keyNode
    public void insert(int keyNode) {
        rootNode = insertRec(rootNode, keyNode);
    }
    // Recursive function to insert a new keyNode in the BST
    private Node insertRec(Node rootNode, int keyNode) {
        // If tree is empty, create a new node
        if (rootNode == null) {
            rootNode = new Node(keyNode);
            return rootNode;
        }
        // Recursively move down the tree
        if (keyNode < rootNode.keyNode)
            rootNode.leftNode = insertRec(rootNode.leftNode, keyNode);
        else if (keyNode > rootNode.keyNode)
            rootNode.rightNode = insertRec(rootNode.rightNode, keyNode);
        // Return the unchanged node pointer
        return rootNode;
    }
    // Method to perform inorder traversal of the tree
    public void inorderTraverse() {
        inorder(rootNode);
    }
    // Recursive function for inorder traversal (Left → Root → Right)
    private void inorder(Node rootNode) {
        if (rootNode != null) {
            inorder(rootNode.leftNode);
            System.out.print(rootNode.keyNode + " ");
            inorder(rootNode.rightNode);
        }
    }
    // Method to perform preorder traversal of the tree
    public void preorderTraverse() {
        preorder(rootNode);
    }
    // Recursive function for preorder traversal (Root → Left → Right)
    private void preorder(Node rootNode) {
        if (rootNode != null) {
            System.out.print(rootNode.keyNode + " ");
            preorder(rootNode.leftNode);
            preorder(rootNode.rightNode);
        }
    }
    // Method to perform postorder traversal of the tree
    public void postorderTraverse() {
        postorder(rootNode);
    }
    // Recursive function for postorder traversal (Left → Right → Root)
    private void postorder(Node rootNode) {
        if (rootNode != null) {
            postorder(rootNode.leftNode);
            postorder(rootNode.rightNode);
            System.out.print(rootNode.keyNode + " ");
        }
    }
    // Method to search for a specific keyNode in the tree
    public boolean searchElement(int keyNode) {
        return searchRec(rootNode, keyNode);
    }
    // Recursive helper function to search for a keyNode in the BST
    private boolean searchRec(Node rootNode, int keyNode) {
        if (rootNode == null)
            return false;
        if (rootNode.keyNode == keyNode)
            return true;
        if (keyNode < rootNode.keyNode)
            return searchRec(rootNode.leftNode, keyNode);
        else
            return searchRec(rootNode.rightNode, keyNode);
    }
    // Method to calculate the minimum value in the BST
    public int calculateMinValue() {
        return calculateMin(rootNode);
    }
    // Recursive function to find the minimum value (leftmost node)
    private int calculateMin(Node rootNode) {
        if (rootNode == null)
            throw new IllegalStateException("Tree is empty");
        if (rootNode.leftNode == null)
            return rootNode.keyNode;
        return calculateMin(rootNode.leftNode);
    }
    // Method to calculate the maximum value in the BST
    public int calculateMaxValue() {
        return calculateMax(rootNode);
    }
    // Recursive function to find the maximum value (rightmost node)
    private int calculateMax(Node rootNode) {
        if (rootNode == null)
            throw new IllegalStateException("Tree is empty");
        if (rootNode.rightNode == null)
            return rootNode.keyNode;
        return calculateMax(rootNode.rightNode);
    }
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        // Insert sample nodes
        tree.insert(12);
        tree.insert(72);
        tree.insert(24);
        tree.insert(60);
        tree.insert(36);
        tree.insert(48);
        tree.insert(84);
        // Display different traversals
        System.out.println("Inorder Traversal (Left → Root → Right):");
        tree.inorderTraverse();   // Output: 20 30 40 50 60 70 80
        System.out.println("\nPreorder Traversal (Root → Left → Right):");
        tree.preorderTraverse();  // Output: 50 30 20 40 70 60 80
        System.out.println("\nPostorder Traversal (Left → Right → Root):");
        tree.postorderTraverse(); // Output: 20 40 30 60 80 70 50
        // Search for a keyNode
        int searchKey = 40;
        if (tree.searchElement(searchKey))
            System.out.println("\nKey " + searchKey + " found in the tree.");
        else
            System.out.println("\nKey " + searchKey + " not found in the tree.");
        // Display minimum and maximum values
        System.out.println("Minimum value in the tree: " + tree.calculateMinValue());
        System.out.println("Maximum value in the tree: " + tree.calculateMaxValue());
    }
}

Compile and Run

C

#include <stdio.h>
#include <stdlib.h>
// Node structure definition
struct Node {
    int keyNode;
    struct Node *leftNode, *rightNode;
};
// Function to create a new node
struct Node* createNode(int item) {
    struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
    temp->keyNode = item;
    temp->leftNode = temp->rightNode = NULL;
    return temp;
}
// Function to insert a node in BST
struct Node* insertRec(struct Node* rootNode, int keyNode) {
    if (rootNode == NULL)
        return createNode(keyNode);
    if (keyNode < rootNode->keyNode)
        rootNode->leftNode = insertRec(rootNode->leftNode, keyNode);
    else if (keyNode > rootNode->keyNode)
        rootNode->rightNode = insertRec(rootNode->rightNode, keyNode);
    return rootNode;
}
// Inorder traversal
void inorder(struct Node* rootNode) {
    if (rootNode != NULL) {
        inorder(rootNode->leftNode);
        printf("%d ", rootNode->keyNode);
        inorder(rootNode->rightNode);
    }
}
// Preorder traversal
void preorder(struct Node* rootNode) {
    if (rootNode != NULL) {
        printf("%d ", rootNode->keyNode);
        preorder(rootNode->leftNode);
        preorder(rootNode->rightNode);
    }
}
// Postorder traversal
void postorder(struct Node* rootNode) {
    if (rootNode != NULL) {
        postorder(rootNode->leftNode);
        postorder(rootNode->rightNode);
        printf("%d ", rootNode->keyNode);
    }
}
// Search an element in the BST
int searchElement(struct Node* rootNode, int keyNode) {
    if (rootNode == NULL)
        return 0;
    if (rootNode->keyNode == keyNode)
        return 1;
    if (keyNode < rootNode->keyNode)
        return searchElement(rootNode->leftNode, keyNode);
    return searchElement(rootNode->rightNode, keyNode);
}
// Find minimum value
int calculateMinValue(struct Node* rootNode) {
    if (rootNode == NULL) {
        printf("Tree is empty\n");
        exit(0);
    }
    while (rootNode->leftNode != NULL)
        rootNode = rootNode->leftNode;
    return rootNode->keyNode;
}
// Find maximum value
int calculateMaxValue(struct Node* rootNode) {
    if (rootNode == NULL) {
        printf("Tree is empty\n");
        exit(0);
    }
    while (rootNode->rightNode != NULL)
        rootNode = rootNode->rightNode;
    return rootNode->keyNode;
}
// Main function
int main() {
    struct Node* rootNode = NULL;
    rootNode = insertRec(rootNode, 12);
    insertRec(rootNode, 72);
    insertRec(rootNode, 24);
    insertRec(rootNode, 60);
    insertRec(rootNode, 36);
    insertRec(rootNode, 48);
    insertRec(rootNode, 84);
    printf("Inorder Traversal (Left → Root → Right):\n");
    inorder(rootNode);
    printf("\n");
    printf("Preorder Traversal (Root → Left → Right):\n");
    preorder(rootNode);
    printf("\n");
    printf("Postorder Traversal (Left → Right → Root):\n");
    postorder(rootNode);
    printf("\n");
    int searchKey = 40;
    if (searchElement(rootNode, searchKey))
        printf("Key %d found in the tree.\n", searchKey);
    else
        printf("Key %d not found in the tree.\n", searchKey);
    printf("Minimum value in the tree: %d\n", calculateMinValue(rootNode));
    printf("Maximum value in the tree: %d\n", calculateMaxValue(rootNode));
    return 0;
}

Compile and Run

C++

#include <iostream>
using namespace std;
// Node structure
struct Node {
    int keyNode;
    Node* leftNode;
    Node* rightNode;
    Node(int item) {
        keyNode = item;
        leftNode = rightNode = nullptr;
    }
};
// BinaryTree class
class BinaryTree {
    Node* rootNode;
public:
    BinaryTree() { rootNode = nullptr; }
    void insert(int keyNode) {
        rootNode = insertRec(rootNode, keyNode);
    }
    Node* insertRec(Node* rootNode, int keyNode) {
        if (!rootNode)
            return new Node(keyNode);
        if (keyNode < rootNode->keyNode)
            rootNode->leftNode = insertRec(rootNode->leftNode, keyNode);
        else if (keyNode > rootNode->keyNode)
            rootNode->rightNode = insertRec(rootNode->rightNode, keyNode);
        return rootNode;
    }
    // Inorder traversal
    void inorderTraverse() {
        inorder(rootNode);
        cout << endl;
    }
    void inorder(Node* rootNode) {
        if (rootNode) {
            inorder(rootNode->leftNode);
            cout << rootNode->keyNode << " ";
            inorder(rootNode->rightNode);
        }
    }
    // Preorder traversal
    void preorderTraverse() {
        preorder(rootNode);
        cout << endl;
    }
    void preorder(Node* rootNode) {
        if (rootNode) {
            cout << rootNode->keyNode << " ";
            preorder(rootNode->leftNode);
            preorder(rootNode->rightNode);
        }
    }
    // Postorder traversal
    void postorderTraverse() {
        postorder(rootNode);
        cout << endl;
    }
    void postorder(Node* rootNode) {
        if (rootNode) {
            postorder(rootNode->leftNode);
            postorder(rootNode->rightNode);
            cout << rootNode->keyNode << " ";
        }
    }
    // Search an element
    bool searchElement(int keyNode) {
        return searchRec(rootNode, keyNode);
    }
    bool searchRec(Node* rootNode, int keyNode) {
        if (!rootNode)
            return false;
        if (rootNode->keyNode == keyNode)
            return true;
        if (keyNode < rootNode->keyNode)
            return searchRec(rootNode->leftNode, keyNode);
        return searchRec(rootNode->rightNode, keyNode);
    }
    int calculateMinValue() {
        Node* current = rootNode;
        while (current->leftNode)
            current = current->leftNode;
        return current->keyNode;
    }
    int calculateMaxValue() {
        Node* current = rootNode;
        while (current->rightNode)
            current = current->rightNode;
        return current->keyNode;
    }
};
// Main
int main() {
    BinaryTree tree;
    tree.insert(12);
    tree.insert(72);
    tree.insert(24);
    tree.insert(60);
    tree.insert(36);
    tree.insert(48);
    tree.insert(84);
    cout << "Inorder Traversal (Left → Root → Right):\n";
    tree.inorderTraverse();
    cout << "Preorder Traversal (Root → Left → Right):\n";
    tree.preorderTraverse();
    cout << "Postorder Traversal (Left → Right → Root):\n";
    tree.postorderTraverse();
    int searchKey = 40;
    if (tree.searchElement(searchKey))
        cout << "Key " << searchKey << " found in the tree.\n";
    else
        cout << "Key " << searchKey << " not found in the tree.\n";
    cout << "Minimum value in the tree: " << tree.calculateMinValue() << endl;
    cout << "Maximum value in the tree: " << tree.calculateMaxValue() << endl;
}

Compile and Run

C#

using System;
// Node class
class Node {
    public int keyNode;
    public Node leftNode, rightNode;
    public Node(int item) {
        keyNode = item;
        leftNode = rightNode = null;
    }
}
// BinaryTree class
class BinaryTree {
    Node rootNode;
    public BinaryTree() {
        rootNode = null;
    }
    // Insert node
    public void Insert(int keyNode) {
        rootNode = InsertRec(rootNode, keyNode);
    }
    private Node InsertRec(Node rootNode, int keyNode) {
        if (rootNode == null)
            return new Node(keyNode);
        if (keyNode < rootNode.keyNode)
            rootNode.leftNode = InsertRec(rootNode.leftNode, keyNode);
        else if (keyNode > rootNode.keyNode)
            rootNode.rightNode = InsertRec(rootNode.rightNode, keyNode);
        return rootNode;
    }
    // Inorder traversal
    public void InorderTraverse() {
        Inorder(rootNode);
        Console.WriteLine();
    }
    private void Inorder(Node rootNode) {
        if (rootNode != null) {
            Inorder(rootNode.leftNode);
            Console.Write(rootNode.keyNode + " ");
            Inorder(rootNode.rightNode);
        }
    }
    // Preorder traversal
    public void PreorderTraverse() {
        Preorder(rootNode);
        Console.WriteLine();
    }
    private void Preorder(Node rootNode) {
        if (rootNode != null) {
            Console.Write(rootNode.keyNode + " ");
            Preorder(rootNode.leftNode);
            Preorder(rootNode.rightNode);
        }
    }
    // Postorder traversal
    public void PostorderTraverse() {
        Postorder(rootNode);
        Console.WriteLine();
    }
    private void Postorder(Node rootNode) {
        if (rootNode != null) {
            Postorder(rootNode.leftNode);
            Postorder(rootNode.rightNode);
            Console.Write(rootNode.keyNode + " ");
        }
    }
    // Search element
    public bool SearchElement(int keyNode) {
        return SearchRec(rootNode, keyNode);
    }
    private bool SearchRec(Node rootNode, int keyNode) {
        if (rootNode == null)
            return false;
        if (rootNode.keyNode == keyNode)
            return true;
        if (keyNode < rootNode.keyNode)
            return SearchRec(rootNode.leftNode, keyNode);
        return SearchRec(rootNode.rightNode, keyNode);
    }
    // Minimum value
    public int CalculateMinValue() {
        Node current = rootNode;
        while (current.leftNode != null)
            current = current.leftNode;
        return current.keyNode;
    }
    // Maximum value
    public int CalculateMaxValue() {
        Node current = rootNode;
        while (current.rightNode != null)
            current = current.rightNode;
        return current.keyNode;
    }
    // Main method
    public static void Main() {
        BinaryTree tree = new BinaryTree();
        tree.Insert(12);
        tree.Insert(72);
        tree.Insert(24);
        tree.Insert(60);
        tree.Insert(36);
        tree.Insert(48);
        tree.Insert(84);
        Console.WriteLine("Inorder Traversal (Left → Root → Right):");
        tree.InorderTraverse();
        Console.WriteLine("Preorder Traversal (Root → Left → Right):");
        tree.PreorderTraverse();
        Console.WriteLine("Postorder Traversal (Left → Right → Root):");
        tree.PostorderTraverse();
        int searchKey = 40;
        if (tree.SearchElement(searchKey))
            Console.WriteLine($"Key {searchKey} found in the tree.");
        else
            Console.WriteLine($"Key {searchKey} not found in the tree.");
        Console.WriteLine("Minimum value in the tree: " + tree.CalculateMinValue());
        Console.WriteLine("Maximum value in the tree: " + tree.CalculateMaxValue());
    }
}

Compile and Run

Output:

Inorder Traversal (Left → Root → Right):
12 24 36 48 60 72 84 
Preorder Traversal (Root → Left → Right):
12 72 24 60 36 48 84 
Postorder Traversal (Left → Right → Root):
48 36 60 24 84 72 12 
Key 40 not found in the tree.
Minimum value in the tree: 12
Maximum value in the tree: 84

Traversal in a Binary Tree

Traversal means visiting each node in a binary tree exactly once in a specific order to process (read, print, or modify) the data stored in them. There are three main depth-first traversal methods:

Inorder
Preorder
Postorder

Inorder Traversal (Left → Root → Right)

In this traversal, the algorithm goes to the root node first, then the left subtree, and lastly the right subtree.
In order to sort nodes in a Binary Search Tree (BST), inorder traversal is used.

Preorder Traversal (Root → Left → Right)

In this instance, the traversal recursively visits the left subtree after processing the root node, and then moves on to the right subtree.
It is primarily utilized to obtain a prefix expression of an expression tree or to make a clone of the tree.

Postorder Traversal (Left → Right → Root)

The algorithm goes to the left subtree, then the right subtree, and lastly the root node in this traversal.
It is helpful for getting a postfix expression in an expression tree or for removing or clearing up the tree's memory.

Next TopicBinary Search Tree

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

Interview Questions

Python Java Data Structure C++ C HTML JavaScript jQuery SQL Power BI

Online Compilers

C Compiler R Compiler C++ Compiler PHP Compiler Java Compiler HTML Editor Swift Compiler Python Compiler JavaScript Editor TypeScript Editor

Latest Post | Tutorials List | Privacy Policy | About Us | Contact Us

Binary Tree

What is a Binary Tree?

Characteristics of a Binary Tree

Example of a Binary Tree

Node Representation of a Binary Tree

Properties of Binary Tree

Types of Binary Tree

1. Full or Strict Binary Tree

2. Complete Binary Tree

3. Perfect Binary Tree

Note: All the perfect binary trees are the complete binary trees as well as the full binary tree, but vice versa is not true, i.e., all complete binary trees and full binary trees are the perfect binary trees.

4. Degenerate Binary Tree

5. Balanced Binary Tree

Binary Tree Implementation

Implementation of Binary Tree in Python/ Java/ C++/ C/ C#

Python

Java

C

C++

C#

Traversal in a Binary Tree

Inorder Traversal (Left → Root → Right)

Preorder Traversal (Root → Left → Right)

Postorder Traversal (Left → Right → Root)

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers

DS Tutorial

DS Array

DS Linked List

DS Stack

DS Queue

DS Tree

DS Graph

DS Searching

DS Sorting

Hashing & Heap

Differences

Binary Tree

Binary Search Tree

AVL Tree

Singly Linked List

Doubly Linked List

Circular Linked List

Circular Doubly List

DS MCQ

Misc

Binary Tree

What is a Binary Tree?

Characteristics of a Binary Tree

Example of a Binary Tree

Node Representation of a Binary Tree

Properties of Binary Tree

Types of Binary Tree

1. Full or Strict Binary Tree

2. Complete Binary Tree

3. Perfect Binary Tree

Note: All the perfect binary trees are the complete binary trees as well as the full binary tree, but vice versa is not true, i.e., all complete binary trees and full binary trees are the perfect binary trees.

4. Degenerate Binary Tree

5. Balanced Binary Tree

Binary Tree Implementation

Implementation of Binary Tree in Python/ Java/ C++/ C/ C#

Python

Java

C

C++

C#

Traversal in a Binary Tree

Inorder Traversal (Left → Root → Right)

Preorder Traversal (Root → Left → Right)

Postorder Traversal (Left → Right → Root)

Related Posts

Subscribe to Tpoint Tech

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers