Skip to content
Related Articles

Related Articles

Binary Tree | Set 1 (Introduction)

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Basic
  • Last Updated : 21 Jun, 2022

A tree is a popular data structure that is non-linear in nature. Unlike other data structures like array, stack, queue, and linked list which are linear in nature, a tree represents a hierarchical structure. The ordering information of a tree is not important. A tree contains nodes and 2 pointers. These two pointers are the left child and the right child of the parent node. Let us understand the terms of tree in detail.

  • Root: The root of a tree is the topmost node of the tree that has no parent node. There is only one root node in every tree.
  • Edge: Edge acts as a link between the parent node and the child node.
  • Leaf: A node that has no child is known as the leaf node. It is the last node of the tree. There can be multiple leaf nodes in a tree.
  • Depth: The depth of the node is the distance from the root node to that particular node.
  • Height: The height of the node is the distance from that node to the deepest node of the tree.
  • Height of tree: The Height of the tree is the maximum height of any node.

      tree
      —-
           j    <– root
       /   \
     f      k  
  /   \      \
a     h      z    <– leaves

Why Use Trees? 

1. One reason to use trees might be because you want to store information that naturally forms a hierarchy. For example, the file system on a computer: 

file system

———–

       user <– root
    /       \
 . . .      home
         /          \
   ugrad        course
    /            /      |     \
. . .      cs101  cs112  cs113

2. Trees (with some ordering e.g., BST) provide moderate access/search (quicker than Linked List and slower than arrays). 
3. Trees provide moderate insertion/deletion (quicker than Arrays and slower than Unordered Linked Lists). 
4. Like Linked Lists and unlike Arrays, Trees don’t have an upper limit on the number of nodes as nodes are linked using pointers.

Main applications of trees include: 

  1. Manipulate hierarchical data. 
  2. Make information easy to search (see tree traversal). 
  3. Manipulate sorted lists of data. 
  4. As a workflow for compositing digital images for visual effects. 
  5. Router algorithms 
  6. Form of multi-stage decision-making (see business chess). 

Binary Tree: A tree whose elements have at most 2 children is called a binary tree. Since each element in a binary tree can have only 2 children, we typically name them the left and right child. 

Binary Tree Representation: A tree is represented by a pointer to the topmost node of the tree. If the tree is empty, then the value of the root is NULL. 
A Tree node contains the following parts. 

  1. Data 
  2. Pointer to the left child 
  3. Pointer to the right child

In C, we can represent a tree node using structures. In other languages, we can use classes as part of their OOP feature. Below is an example of a tree node with integer data.

C




// Structure of each node of the tree
 
struct node
{
    int data;
    struct node* left;
    struct node* right;
};


C++




//Use any below method to implement Nodes of tree
 
// Method 1: Using "struct" to make
// user-define data type
struct node
{
    int data;
    struct node* left;
    struct node* right;
};
 
// Method 2: Using "class" to make
// user-define data type
class Node
{
  public:
    int data;
    Node* left;
    Node* right;
};


Python




# A Python class that represents
# an individual node in a Binary Tree
 
class Node:
    def __init__(self,key):
        self.left = None
        self.right = None
        self.val = key


Java




// Class containing left and right child
// of current node and key value
class Node
{
    int key;
    Node left, right;
 
    public Node(int item)
    {
        key = item;
        left = right = null;
    }
}


C#




// Class containing left and right child
// of current node and key value
 
class Node
{
    int key;
    Node left, right;
 
    public Node(int item)
    {
        key = item;
        left = right = null;
    }
}


Javascript




<script>
/* Class containing left and right child of current
   node and key value*/
 
class Node
{
    constructor(item)
    {
        this.key = item;
        this.left = this.right = null;
    }
}
 
// This code is contributed by umadevi9616
</script>


Basic Operation On Binary Tree:

  • Inserting an element.
  • Removing an element.
  • Searching for an element.
  • Traversing an element. There are three types of traversals in a binary tree which will be discussed ahead.

Auxiliary Operation On Binary Tree:

  • Finding the height of the tree
  • Find the level of the tree
  • Finding the size of the entire tree.

Applications of Binary Tree:

  • In compilers, Expression Trees are used which is an application of binary tree.
  • Huffman coding trees are used in data compression algorithms.
  • Priority Queue is another application of binary tree that is used for searching maximum or minimum in O(logN) time complexity.

Binary Tree Traversals:

  • PreOrder Traversal: Here, the traversal is: root – left child – right child. It means that the root node is traversed first then its left child and finally the right child.
  • InOrder Traversal: Here, the traversal is: left child – root – right child.  It means that the left child is traversed first then its root node and finally the right child.
  • PostOrder Traversal: Here, the traversal is: left child – right child – root.  It means that the left child is traversed first then the right child and finally its root node.

Let us traverse the following tree with all the three traversal methods:

Tree
________________

                 1 //Root Node
                / \
               2    3
              / \  / \
             4  5  6  7 //Leaf Nodes

PreOrder Traversal of the above tree: 1-2-4-5-3-6-7
InOrder Traversal of the above tree: 4-2-5-1-6-3-7
PostOrder Traversal of the above tree: 4-5-2-6-7-3-1

First Simple Tree 
Let us create a simple tree with 4 nodes. The created tree would be as follows. 

      tree
      ----
       1    <-- root
     /   \
    2     3  
   /   
  4

C++




#include <bits/stdc++.h>
using namespace std;
 
class Node {
  public:
    int data;
    Node* left;
    Node* right;
 
    // Val is the key or the value that
    // has to be added to the data part
    Node(int val)
    {
        data = val;
 
        // Left and right child for node
        // will be initialized to null
        left = NULL;
        right = NULL;
    }
};
 
int main()
{
 
    /*create root*/
    Node* root = new Node(1);
    /* following is the tree after above statement
 
             1
            / \
        NULL   NULL
    */
 
    root->left = new Node(2);
    root->right = new Node(3);
    /* 2 and 3 become left and right children of 1
                  1
                /   \
                2      3
               / \     / \
            NULL NULL NULL NULL
    */
 
    root->left->left = new Node(4);
    /* 4 becomes left child of 2
              1
            /    \
           2      3
          / \     / \
         4 NULL NULL NULL
        / \
      NULL NULL
    */
 
    return 0;
}


C




#include <stdio.h>
#include <stdlib.h>
 
struct node {
    int data;
    struct node* left;
    struct node* right;
};
 
/* newNode() allocates a new node
with the given data and NULL left
and right pointers. */
struct node* newNode(int data)
{
    // Allocate memory for new node
    struct node* node
        = (struct node*)malloc(sizeof(struct node));
 
    // Assign data to this node
    node->data = data;
 
    // Initialize left and
    // right children as NULL
    node->left = NULL;
    node->right = NULL;
    return (node);
}
 
int main()
{
    /*create root*/
    struct node* root = newNode(1);
    /* following is the tree after above statement
         1
        / \
      NULL NULL
    */
 
    root->left = newNode(2);
    root->right = newNode(3);
    /* 2 and 3 become left and right children of 1
            1
         /    \
        2      3
      /  \    /  \
   NULL NULL NULL NULL
    */
 
    root->left->left = newNode(4);
    /* 4 becomes left child of 2
             1
         /    \
        2      3
      /  \    /  \
     4 NULL NULL NULL
    / \
 NULL NULL
    */
 
    getchar();
    return 0;
}


Java




// Class containing left and right child
// of current node and key value
class Node {
    int key;
    Node left, right;
 
    public Node(int item)
    {
        key = item;
        left = right = null;
    }
}
 
// A Java program to introduce Binary Tree
class BinaryTree {
     
    // Root of Binary Tree
    Node root;
 
    // Constructors
    BinaryTree(int key) { root = new Node(key); }
 
    BinaryTree() { root = null; }
 
    public static void main(String[] args)
    {
        BinaryTree tree = new BinaryTree();
 
        // create root
        tree.root = new Node(1);
 
        /* following is the tree after above statement
 
              1
            /   \
          null  null     */
 
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
 
        /* 2 and 3 become left and right children of 1
               1
            /     \
          2        3
        /   \     /  \
      null null null null  */
 
        tree.root.left.left = new Node(4);
        /* 4 becomes left child of 2
                    1
                /       \
               2          3
             /   \       /  \
            4    null  null  null
           /   \
          null null
         */
    }
}


Python




# Python program to introduce Binary Tree
 
# A class that represents an individual node
# in a Binary Tree
class Node:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key
 
 
if __name__ == '__main__':
    # Create root
    root = Node(1)
    ''' following is the tree after above statement
        1
      /   \
     None  None'''
     
    root.left = Node(2)
    root.right = Node(3)
    ''' 2 and 3 become left and right children of 1
           1
         /   \
        2      3
     /    \    /  \
    None None None None'''
     
    root.left.left = Node(4)
    '''4 becomes left child of 2
               1
           /       \
          2          3
        /   \       /  \
       4    None  None  None
      /  \
    None None'''


C#




// A C# program to introduce Binary Tree
using System;
 
// Class containing left and right child
// of current node and key value
public class Node {
    public int key;
    public Node left, right;
 
    public Node(int item)
    {
        key = item;
        left = right = null;
    }
}
 
public class BinaryTree {
     
    // Root of Binary Tree
    Node root;
 
    // Constructors
    BinaryTree(int key) {
        root = new Node(key);
    }
 
    BinaryTree() {
        root = null;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        BinaryTree tree = new BinaryTree();
 
        // Create root
        tree.root = new Node(1);
 
        /* Following is the tree after above statement
 
             1
            / \
         null null     */
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
 
        /* 2 and 3 become left and right children of 1
                1
             /     \
           2        3
         /  \     /   \
       null null null null */
        tree.root.left.left = new Node(4);
 
        /* 4 becomes left child of 2
                1
             /     \
           2        3
         /  \     /   \
         4 null null null
        / \
     null null
        */
    }
}
 
// This code is contributed by PrinciRaj1992


Javascript




<script>
/* Class containing left and right child of current
   node and key value*/
 class Node {
        constructor(val) {
            this.key = val;
            this.left = null;
            this.right = null;
        }
    }
  
 
// A javascript program to introduce Binary Tree
 
    // Root of Binary Tree
    var root = null;
 
     
 
        /*create root*/
        root = new Node(1);
 
        /* following is the tree after above statement
 
              1
            /   \
          null  null     */
 
        root.left = new Node(2);
        root.right = new Node(3);
 
        /* 2 and 3 become left and right children of 1
               1
            /     \
          2        3
        /   \     /  \
      null null null null  */     
      root.left.left = new Node(4);
        /* 4 becomes left child of 2
                    1
                /       \
               2          3
             /   \       /  \
            4    null  null  null
           /   \
          null null
         */
  
// This code contributed by umadevi9616
</script>


Summary: Tree is a hierarchical data structure. Main uses of trees include maintaining hierarchical data, providing moderate access and insert/delete operations. Binary trees are special cases of tree where every node has at most two children.

Below are set 2 and set 3 of this post. 
Properties of Binary Tree 
Types of Binary Tree
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!