Binary Tree

Binary tree has these major parts

 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.

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:

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

struct node

int data;

struct node* left;

struct node* right;

};

 Java

class Node
{
int key;
Node left, right;
public Node(int item)
{
key = item;
left = right = null;
}
}

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.

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

 Code
 // 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
 */
 }
 }