# Binary Tree | Set 1 (Introduction)

• 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
/          \
/            /      |     \
. . .      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

 ``

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 ` `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 ` `#include `   `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

 ``

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