# Tree Implementation in Java

## Introduction to Tree

A non-linear, hierarchical data structure called a "tree" is made up of a number of nodes, each of which contains a values and a sequence of pointers to other nodes.

The above data structure is a particular way to set up data storage and arrangement in the computer so that it can be used much more efficiently. It is made up of basic nodes, sub-nodes, and a center node that are all interconnected by edges. The roots, branches, and leaves of a tree data structure are all linked to one another.

## Properties of Tree Data Structure

**Non-Linear Nature**

In other words, a tree does not store its data properly or in a systematic way. Rather, they are grouped in a hierarchical system with several layers. Thus, the tree is regarded as a non-linear data structure as a result.

**Recursive Nature**

The word "tree" is sometimes used to describe a recursive data structure. Because the distinguishing node in a tree data structure is referred to as a root node, a tree can be described as recursive data structure. The roots of subtrees of the trees are linked from the root node. The left subtree can be divided further into the three subtrees represented in various types. Recursion is the mathematical concept of self-similar reduction. As a result, many implementations use the tree data structure's recursive characteristic.

**Number of Edges**

The link that connects two nodes is referred to as an edge. A tree will have (N-1) edges if it contains N nodes. There is only one method to move from every node to another node in the tree.

**Depth of the node**

The distance from the root to a node is referred to as the node's depth. The path gains one unit of length for each edge. As a result, it may alternatively be described as the quantity of edges along the route leading from the tree's root to each node.

**Height of node**

The height of a node can be defined as the length of the longest path from the node to a leaf node of the tree.

**Height of Tree**

The distance along the longest path from a tree's root to one of its leaf nodes determines the size of the tree.**Degree of node**

The level of the node or the degree is the total number of subtrees that are connected to that node. A leaf node must have a degree of 0. The highest degree achieved by a node from all other nodes in the tree is the degree of the tree.

## Types of Tree data structures

The following are the types of trees in java

- General Tree
- Binary Tree
- Binary Search Tree
- B- Tree

### General Tree

One of the different kinds of tree data structures is the general tree. A node in the general tree can have a capacity of n nodes or Nil nodes. There are no restrictions placed on the degree of the node (the total count of nodes which a node can hold). A root node is the first node in a basic tree. Subtrees are the parent node's grandchildren.

A general tree could include n number of subtrees. The subtrees in the general tree are not organized since the subtree's nodes can not be arranged.

The downstream edges of any non-empty tree are linked to the nodes referred to as child nodes. Level 0 denotes to the base node. Sibling nodes are those who share the same parent node.

### Binary Tree

Binary trees are trees in which every node (parent) has a maximum of two children (left and right). The root node is the highest node in the tree. The information and reference (address) of the left and right child nodes are represented in each node of a binary tree.

A binary tree's height is determined by how many connections are there between its root and its longest (deepest) leaf. The height is zero if the tree is empty. The letter h stands for the node's height.

The procedure below can be used to determine the number of nodes and leaves.

- The most leaf nodes a binary tree can have is denoted by "2h".
- The most nodes a binary tree can have or contain are "2h+1-1".

### Binary Search Tree

A binary search tree is a binary tree where every other node has an Unique key (and an associated value) and fits with the condition that no node's key must be both greater than and smaller than all other nodes' keys in both the left and right subtrees of that node.

**Properties**

There are certain rules while constructing a binary search tree. They are as following:

- A node's left subtree only has nodes with values lower than the node itself.
- Those nodes with values higher than the node's value are found in the right subtree of the node.
- A binary search tree needs to be represented in both the left and right subtrees.

### B-Tree

A specific m-way tree that is frequently used for disc access termed as the B Tree. A B-Tree of type m can contain m children and at most m-1 nodes. One of the primary advantages of implementing a B tree is its capable of storing many keys in a single point and huge key values while having a consistent small tree height

**Properties**

- The height of each leaf node is the similar.
- The phrase minimal degree "t" implies a B-Tree. The size of a file system determines the value of t.
- All nodes must have t-1 keys, with the exception of root. The root may have at least one key.
- For most 2*t - 1 values may be present in any node, along with the root.
- A node has as many children as its amount of keys plus one.
- A node's keys are arranged in ascending order. All keys inside the range among both k1 and k2 are contained in the child between k1 and k2.
- In contradiction to Binary Search Tree, the B-Tree expands and decreases from the base. Binary search trees can both expand and diminish .

## Implementation of General Tree

### Rules to be followed

- A tree is a node. The tree's root is situated at that node.
- We can establish a new tree where t will be the parent of the nodes t1, t2,..., tk if r is a node and S1, S2,..., Sk are subtrees with roots t1, t2,..., tk. S1, S2,..., and Sk are subtrees of the root of the new tree, where r is the root. The nodes t1, t2,..., and tk are referred to as the node r's children.
- The empty tree can be helpful at times. There are no nodes in this tree.

Let us understand the implementation of a general tree with an example program

```
// Java program to do level order traversal
// of a generic tree
import java.util.*;
class Demo111
{
// Representation of a node in n-ary tree
static class Node
{
int key;
Vector<Node >child = new Vector<>();
};
// Utility function to create a new tree node
static Node newNode(int key)
{
Node tem = new Node();
temp.key = key;
return tem;
}
// Prints the n-ary tree level wise
static void LOT(Node root)
{
if (root == null)
return;
// Standard level order traversal code
// using queue
Queue<Node > rk = new LinkedList<>(); // Create a queue
rk.add(root); // Enqueue root
while (!rk.isEmpty())
{
int n = rk.size();
// If this node has children
while (n > 0)
{
// Dequeue an item from queue
// and print it
Node p =rk.peek();
rk.remove();
System.out.print(p.key + " ");
// Enqueue all children of
// the dequeued item
for (int i = 0; i < p.child.size(); i++)
rk.add(p.child.get(i));
n--;
}
// Print new line between two levels
System.out.println();
}
}
// Driver Code
public static void main(String[] args)
{
Node ob = newNode(11);
(ob.child).add(newNode(3));
(ob.child).add(newNode(37));
(ob.child).add(newNode(51));
(ob.child).add(newNode(111));
(ob.child.get(0).child).add(newNode(74));
(ob.child.get(0).child).add(newNode(83));
(ob.child.get(2).child).add(newNode(2));
(ob.child.get(3).child).add(newNode(9));
(ob.child.get(3).child).add(newNode(7));
(ob.child.get(3).child).add(newNode(6));
System.out.println("Level order traversal " +"Before Mirroring ");
LOT (root);
}
}
```

**Output**

```
Level order traversal of the general tree
11
3 37 51 111
74 83 2 9 7 6
```

The above program depicts of how the general tree is implemented in Java.

Initially a root node of the tree is created. Then the children of that tree which implies the child nodes of the tree are created. The nodes corresponding to the left part of the entire tree is called as left-subtree. The nodes corresponding to the right part of the entire tree is called as right-subtree.

In the of a general tree, child nodes are stored in a vector. As a result, we arrange all of the vector's components.

## Implementation of Binary Tree

**Types of Implementations in Binary Tree**

**Pre-Order Traversal**: Root - Left Child - Right Child is the order of traversing. This indicates that the root node is travelled through initially, followed by its left child or the left sub-tree and then its right child or the right-subtree.

**In-Order Traversal**: Left child, root, and right child make up the traversal. The left child, its root node, and subsequently the right child is traversed in that order.

**Post-Order Traversal**: Left child - right child - root is the traversing order. It indicates that the left child is followed by the right child and then the root node.

Let us understand the implementation of a binary tree with an example program

```
// Binary Tree in Java
// Creation of Node
class Node111 {
int key;
Node left, right;
public Node(int item) {
key = item;
left = right = null;
}
}
class BT {
Node root;
BT(int key) {
root = new Node(key);
}
BT() {
root = null;
}
// In-order Traversal
public void traverseInOrder(Node node) {
if (node != null) {
traverseInOrder(node.left);
System.out.print(" " + node.key);
traverseInOrder(node.right);
}
}
// Post-order Traversal
public void traversePostOrder(Node node) {
if (node != null) {
traversePostOrder(node.left);
traversePostOrder(node.right);
System.out.print(" " + node.key);
}
}
//Pre-order Traversal
public void traversePreOrder(Node node) {
if (node != null) {
System.out.print(" " + node.key);
traversePreOrder(node.left);
traversePreOrder(node.right);
}
}
public static void main(String[] args) {
BinaryTree tr = new BinaryTree();
tr.root = new Node(11);
tr.root.left = new Node(12);
tr.root.right = new Node(13);
tr.root.left.left = new Node(14);
System.out.print("Pre order Traversing: ");
tr.traversePreOrder(tree.root);
System.out.print("\nIn order Traversing: ");
tr.traverseInOrder(tree.root);
System.out.print("\nPost order Traversing: ");
tr.traversePostOrder(tree.root);
}
}
```

**Output**

```
Pre order Traversing: 1 2 4 3
In order Traversing: 4 2 13
Post order Traversing: 4 2 3 1
```

**Summary of Binary Tree**

A topological data structure is a tree. Trees are mostly used for insert/delete tasks, modest access, and keeping data structure. A binary tree is a special type of tree where each node has a maximum of two offspring.

**Applications**

- Expression Trees, a binary tree implementation, are employed in interpreters.
- Techniques for lossless compression employ Huffman coding trees.
- A further binary tree implementation that searches maximum or minimum in O(1) time complexity is priority queue.

## Implementation of Binary Search Tree

The Binary Search Tree is implemented in many ways using many operations. They are discussed as below:

- Insertion
- Deletion

### Insertion

- If the value of the new node is less than the root node then, it will be inserted to the left subtree.
- If the value of the new node is greater than root node then, it will be inserted to the right subtree.

### Deletion

- A binary search tree's given node could be removed using the delete operation. But, we have to remove a node from a binary search tree in a manner it doesn't contradict that criteria.
- If the node to be deleted is a leaf node,
- If the node that has to be deleted has only one child, try replacing the node in this instance with its child and then remove the child node because it currently consists the value that needs to be deleted. Consider replacing it with Zero values to release the space that was allotted.
- If the node that has to be deleted has two children, then it is a bit complex situation. Right till the node value is inserted on the tree leaf, the node that has to removed is successively replaced by its in-order successor or predecessor. Update the node with Zero values and release the space after the process.

The below program shall depict the implementation of binary search tree using the above discussed operations.

```
public class BST {
//Representation of binary tree structure
public static class Node{
int data;
Node left;
Node right;
public Node(int data){
//Assign data to the new node, set left and right children to null
this.data = data;
this.left = null;
this.right = null;
}
}
//Representation if binary tree structure
public Node root;
public BinarySearchTree(){
root = null;
}
//insert() method shall help in adding the node
public void insert(int data) {
//Creation a new node
Node ob = new Node(data);
//Verifying if tree is empty
if(root == null){
root = ob;
return;
}
else {
//current node points to root node of the tree
Node current = root, parent = null;
while(true) {
parent = current;
// Node would be introduced towards the left of the current node if value is less than current value of tree
if(data < current.data) {
current = current.left;
if(current == null) {
parent.left = ob;
return;
}
}
//The node will be inserted towards the right side of the tree if the value is greater than current value
else {
current = current.right;
if(current == null) {
parent.right = ob;
return;
}
}
}
}
}
//minNode() method is used to find the node with minimum value
public Node minNode(Node root) {
if (root.left != null)
return minNode(root.left);
else
return root;
}
//deleteNode() method is used to remove the node from the given binary tree
public Node deleteNode(Node node, int value) {
if(node == null){
return null;
}
else {
//must search towards the left of the tree if the value is lee than the given data
if(value < node.data)
node.left = deleteNode(node.left, value);
//search towards right side of the node data if the value is greater than node data
else if(value > node.data)
node.right = deleteNode(node.right, value);
//If the searching value is found then there is no need to search
{
//The node meant to be deleted has no child then consider it null
if(node.left == null && node.right == null)
node = null;
//The node which is meant to be deleted has only right child
else if(node.left == null) {
node = node.right;
}
//The node which is meant to be deleted has only left child
else if(node.right == null) {
node = node.left;
}
//The node which is meant to be deleted has two children nodes
else {
//then find the minimum node from right subtree
Node tem = minNode(node.right);
//Exchange the data between node and temp
node.data = tem.data;
//Delete the node duplicate node from right subtree
node.right = deleteNode(node.right, tem.data);
}
}
return node;
}
}
//inorder() will perform inorder traversal on binary search tree
public void inorderTraversal(Node node) {
//Check whether tree is empty
if(root == null){
System.out.println("Tree is empty");
return;
}
else {
if(node.left!= null)
inorderTraversal(node.left);
System.out.print(node.data + " ");
if(node.right!= null)
inorderTraversal(node.right);
}
}
public static void main(String[] args) {
BinarySearchTree rk = new BinarySearchTree();
//Add nodes to the binary tree
rk.insert(10);
rk.insert(20);
rk.insert(30);
rk.insert(40);
rk.insert(50);
rk.insert(60);
System.out.println("Binary search tree after inserting the values:");
//Displays the binary tree
rk.inorderTraversal(rk.root);
Node deletedNode = null;
//Deletes node 60 which has no child
deletedNode = rk.deleteNode(bt.root, 60);
System.out.println("\nBinary search tree after deleting node 90:");
rk.inorderTraversal(bt.root);
//Deletes node 30
deletedNode = rk.deleteNode(bt.root, 30);
System.out.println("\nBinary search tree after deleting node 30:");
rk.inorderTraversal(rk.root);
//Deletes node 50
deletedNode = rk.deleteNode(bt.root, 50);
System.out.println("\nBinary search tree after deleting node 50:");
rk.inorderTraversal(rk.root);
}
}
```

**Output**

```
Binary search tree after inserting the values:
10 20 30 40 50 60
Binary search tree after deletion node 60:
10 20 30 40 50
Binary search tree after deleting node 30:
10 20 40 50
Binary search tree after deleting node 50:
10 20 40
```

## Implementation of B-Tree

The operations for implementing the B-Tree are

- Searching
- Traversal

### Searching

The search process is comparable to that of a binary search tree. Let "m" be the searchable key. Iteratively, we move across the tree starting at the root. If the node holds the key for any visited non-leaf nodes, we just return the node. If not, we go back to the node's corresponding child (the child that comes before the first greater key). It provides NULL if we approach a leaf node but can't find "m" there.

### Traversal

Traversal is comparable to in-order binary tree traversal. Iteratively printing the left child after starting with the first one, we continue in the same manner with the values and subsequent children. Iteratively display the rightmost child at the conclusion.

The below program shall depict the implementation of B-Tree with the suitable operations.

```
// Searching a key on a B-tree in Java
public class BTree {
private int T;
// Node creation
public class Node {
int n;
int key[] = new int[2 * T - 1];
Node child[] = new Node[2 * T];
boolean leaf = true;
public int Find(int k) {
for (int i = 0; i < this.n; i++) {
if (this.key[i] == k) {
return i;
}
}
return -1;
};
}
public BTree(int t) {
T = t;
root = new Node();
root.n = 0;
root.leaf = true;
}
private Node root;
// Search key
private Node Search(Node x, int key) {
int i = 0;
if (x == null)
return x;
for (i = 0; i < x.n; i++) {
if (key < x.key[i]) {
break;
}
if (key == x.key[i]) {
return x;
}
}
if (x.leaf) {
return null;
} else {
return Search(x.child[i], key);
}
}
// Splitting the node
private void Split(Node x, int pos, Node y) {
Node z = new Node();
z.leaf = y.leaf;
z.n = T - 1;
for (int j = 0; j < T - 1; j++) {
z.key[j] = y.key[j + T];
}
if (!y.leaf) {
for (int j = 0; j < T; j++) {
z.child[j] = y.child[j + T];
}
}
y.n = T - 1;
for (int j = x.n; j >= pos + 1; j--) {
x.child[j + 1] = x.child[j];
}
x.child[pos + 1] = z;
for (int j = x.n - 1; j >= pos; j--) {
x.key[j + 1] = x.key[j];
}
x.key[pos] = y.key[T - 1];
x.n = x.n + 1;
}
// Inserting a value
public void Insert(final int key) {
Node r = root;
if (r.n == 2 * T - 1) {
Node s = new Node();
root = s;
s.leaf = false;
s.n = 0;
s.child[0] = r;
Split(s, 0, r);
insertValue(s, key);
} else {
insertValue(r, key);
}
}
// Insert the node
final private void insertValue(Node x, int k) {
if (x.leaf) {
int i = 0;
for (i = x.n - 1; i >= 0 && k < x.key[i]; i--) {
x.key[i + 1] = x.key[i];
}
x.key[i + 1] = k;
x.n = x.n + 1;
} else {
int i = 0;
for (i = x.n - 1; i >= 0 && k < x.key[i]; i--) {
}
;
i++;
Node tmp = x.child[i];
if (tmp.n == 2 * T - 1) {
Split(x, i, tmp);
if (k > x.key[i]) {
i++;
}
}
insertValue(x.child[i], k);
}
}
public void Show() {
Show(root);
}
// Display
private void Show(Node x) {
assert (x == null);
for (int i = 0; i < x.n; i++) {
System.out.print(x.key[i] + " ");
}
if (!x.leaf) {
for (int i = 0; i < x.n + 1; i++) {
Show(x.child[i]);
}
}
}
// Check if present
public boolean Contain(int k) {
if (this.Search(root, k) != null) {
return true;
} else {
return false;
}
}
public static void main(String[] args) {
BTree b = new BTree(3);
b.Insert(8);
b.Insert(9);
b.Insert(10);
b.Insert(11);
b.Insert(15);
b.Insert(20);
b.Insert(17);
b.Show();
if (b.Contain(12)) {
System.out.println("\nfound");
} else {
System.out.println("\nnot found");
}
;
}
}
```

**Output**

```
10 8 9 11 15 17 20
not found
```