# Binary Tree | Set 1 (Introduction)

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:**

- Manipulate hierarchical data.
- Make information easy to search (see tree traversal).
- Manipulate sorted lists of data.
- As a workflow for compositing digital images for visual effects.
- Router algorithms
- 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.

- Data
- Pointer to the left child
- 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(1) 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.