Types of Tree in Data Structure

Before understanding the types of Tree in Data Structure, first, let us understand what is Tree as a Data Structure. The tree can be defined as a non-linear data structure that stores data in the form of nodes and nodes are connected to each other with the help of edges. Among all the nodes there is one main node called root node and all other nodes are the children of these nodes. There are some properties or rules that each and every node should follow or satisfy. And these rules are:

Each tree emerges from the one main node called the root node. And all other nodes are children of this root node. The root node doesn't have any parent.
Each node in a tree can have multiple children associated with that particular parent node but each child node should have only one parent node strictly.
Each parent node in the tree is connected to its child node with the help of an edge that will be used to traverse the tree in case the traversal of the tree is needed. In some types of trees, their edges are denoted some numeric value called cost of that is used to determine the overall cost of traversing or traversing that particular node of the tree will be calculated by adding all the edges that are used to join that particular node to the root node.

As we can see in the above image, there is shown a tree having a root node named A and having three children named B, C, and D. And the child node B again have two children nodes by the name E and F. Similarly, the node C has three child nodes named G, H and I. And same for node D having J and K as child nodes. If we want to traverse to node J, first we will start from the root node A and then go to the child node D and then finally reach node J.

The various types of trees that are available:

General Tree
Binary Tree
Binary Search Tree
AVL Tree
Red Black Tree
N-ary Tree

Now let us see each one of them in detail to have a better understanding of each of them.

General Tree:

A General Tree is one of the basic forms of Tree Data Structure. In General Tree, each node can have either zero or more than zero nodes associated with it as the child nodes. The subtree of a general tree does not hold the ordered property. In a general tree, a node can have at most n (number of child nodes) nodes. If no constraint is placed on the tree's hierarchy, a tree is called a general tree. Every node may have infinite numbers of children in the General Tree. The tree is the super-set of all other trees.

Code:

// Java program to create and level order traverse a generic or general tree
 
// util package is imported to use classes like Queue and LinkedList
import java.util.*;
 
 
// a public class named GeneralTree is created
public class GeneralTree{
 
 
// A inner class named Node is created representing a single node of a generic tree
static class Node
{
 
// The class Node has two class variables named key and child of int type and Vector<Node> type respectively.
 
int key;
Vector<Node >child = new Vector<>();
};
 
 
// An Utility function named newNode is created to add a new child node to an already existing tree node
public static Node newNode(int key)
{
 
// a temporary node is created and then it is attached as a child to the existing parent node
Node temp = new Node();
temp.key = key;
return temp;
}
 
// a public static function named LevelOrderTraversal is created to print all the nodes in the tree level-wise starting from the root node which passed a parameter to the LevelOrderTraversal fucntion
 
public static void LevelOrderTraversal(Node root)
{
if (root == null)
return;
 
// Standard level order traversal code
// Queue is used to traverse the tree level-wise starting from the root node
Queue<Node > q = new LinkedList<>(); // Create a queue
q.add(root); // Enqueue root
while (!q.isEmpty()){
 
int n = q.size();
 
// If this node has children
while (n > 0)
{
// Dequeue an item from queue
// and print it
Node p = q.peek();
q.remove();
System.out.print(p.key + " ");
 
// Enqueue all children of
// the dequeued item
for (int i = 0; i < p.child.size(); i++)
q.add(p.child.get(i));
n--;
}
// One level is completed
// Now nodes in the next level is printed in the next line and same task is repeated each time the nodes in a level are exhausted
System.out.println();
}
}
 
// main function is created to call all the above created functions and create a general tree
public static void main(String[] args){
/* Now we will be creating this general tree using the Node class objects
*                      10
*     /   /     \      \
*   2   34   56    100
*   / \   |     /  |  \
*           77  88        1   7  8  9
*/
 
 
// creating a root node with value 10
Node root_node = newNode(10);
 
// adding four childs to the root node having values 2, 34, 56, adn 100 respectively
(root_node.child).add(newNode(2));
(root_node.child).add(newNode(34));
(root_node.child).add(newNode(56));
(root_node.child).add(newNode(100));
 
// adding two child nodes to the first child node of the root node having values 77, and 88 respectively
(root_node.child.get(0).child).add(newNode(77));
(root_node.child.get(0).child).add(newNode(88));
 
 
// adding one child nodes to the third child node of the root node having values 1
(root_node.child.get(2).child).add(newNode(1));
 
// adding three child nodes to the fourth child node of the root node having values 7, 8, and 9 respectively
(root_node.child.get(3).child).add(newNode(7));
(root_node.child.get(3).child).add(newNode(8));
(root_node.child.get(3).child).add(newNode(9));
 
System.out.println("Printing the nodes of tree level wise :");
System.out.println("Level order traversal : ");
 
LevelOrderTraversal(root_node);
}
 
}
//end of the public GeneralTree Class

Output:

Printing the nodes of tree level wise :
Level order traversal :
(level 0) 10
(level 1) 2 34 56 100
(level 2) 77 88 1 7 8 9

In the code written above, we have created a class named GenralTree that has one static inner class named Node that will depict the actual node of a tree. And we have also a public static function named newNode that is used to add a new node to the tree and the value that the newly added node holding is passed as a parameter to this newNode function.

In the main function first, we have created a root node as an object of the inner static class named Node having a value of 10. Then we added four nodes as the child nodes to the root having values 2, 34, 56, and 100. There newly added four children will be in level 1 and the root node will be in level 0. Now we added two child nodes to the first node in level 1 (i.e., node having value 2) having values 77 and 88 respectively. Further, we added one child node to the second node in level 1 (i.e., node having value 34) having value 1. And in the last, we added three child nodes to the last node in level 1 (i.e., node having value 100) having values 7, 8, and 9 respectively.

Once the tree is created successfully, we have printed the tree level-wise, which means the nodes in one level are printed and then the nodes in the next level are printed until all the nodes in the tree are exhausted.

And for printing the tree level-wise, we have created a function named LevelOrderTraversal that will print the tree level-wise. After the successful creation of the tree, we have called the LevelOrderTraversal passing the root of the node as a parameter to the LevelOrderTraversal function.

Binary Tree:

A binary tree can be defined as one of the trees in which only two children can be added to each parent node. The child nodes are known as the left child node and right child node. A binary tree is one of the most popular trees. When we apply various constraints and characteristics to a Binary tree, various numbers of other trees such as AVL tree, BST (Binary Search Tree), RBT tree, etc. are formed. We will explain in detail these types of trees in further discussion.

In other words, we can say that a generic tree whose elements have at most two 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 children.

A Binary Tree node contains the following parts.

Data
Pointer to the left child
Pointer to the right child

Code:

// Java program to create and level order traverse a binary tree
 
 
// util package is imported to use classes like Queue and LinkedList
import java.util.*;
 
 
 
// A class named Node is created representing a single node of a binary tree
class Node{
 
 
  // The class Node has three class variables named key and left and right of int type and Node type respectively.
 
 
  // the key variable holds the actual value that is assigned to that node of the binary tree
  int key;
 
  // left and right variables that are of Node type will be used to store the left and right child nodes of the parent of the binary tree
  Node left, right;
 
// a parameterized constructor is created to create and add data to the node at the same time.
  public Node(int item)
  {
    key = item;
    left = right = null;
  }
 
 }
// end of node class definition
 
// A public class named BinaryTree is created having two constructors and methods to print the binary tree level-wise.
 
class BinaryTree{
 
  // A static variable named root_node is created that will represent the node of the binary tree
  static Node root_node;
 
 
 
 
  // A parametrized constructor of the BinaryTree class is written having the key as a parameter
  BinaryTree(int key)
  {
 
// here we are constructing a new node and assigning it to the root node
    root_node = new Node(key);
  }
 
  BinaryTree()
  {
    root_node = null;
  }
 
 
 
// a public static function named printLevelOrder is created to print all the nodes in the tree level-wise starting from the root node
 
 public static void printLevelOrder()
    {
        int h = height(root_node);
        int i;
        for (i=1; i<=h; i++){
            printCurrentLevel(root_node, i);
            System.out.println();
          }
    }
 
// a public static function named height is created to fund the height of the binary tree starting from the root node to the farthest leaf node that is present in the binary tree
 
// the root node of the binary tree is passed as a parameter to the public static function named height
 
    public static int height(Node root){
 
        if (root == null)
           return 0;
        else
        {
            /* compute  height of each subtree */
            int lheight = height(root.left);
            int rheight = height(root.right);
             
            /* use the larger one */
            if (lheight > rheight)
                return(lheight+1);
            else return(rheight+1);
        }
    }
 
 
// a Public static function named printCurrrntLevel is created to print al the nodes that are present in that level
 
// this function is called repeatedly for the each level of the binary tree
 
   public static void printCurrentLevel (Node root ,int level)
    {
        if (root == null)
            return;
        if (level == 1)
            System.out.print(root.key + " ");
        else if (level > 1)
        {
            printCurrentLevel(root.left, level-1);
            printCurrentLevel(root.right, level-1);
        }
    }
 
 
//the main function is created to create an object of the BinaryTree class and call the printLevelOrder method to level-wise print the nodes of the binary tree
 
  public static void main(String[] args){
 
    
 
 
    // first of all we have created an Object of the BinaryTree class that will represent the binary tree
    BinaryTree tree = new BinaryTree();
 
 
    // now a new node with the value as 150 is added as the root node to the Binary Tree
    tree.root_node = new Node(150);
 
    // now a new node with the value 250 is added as a left child to the root node
    tree.root_node.left = new Node(250);
 
    // now a new node with the value 270 is added as a right child to the root node
    tree.root_node.right = new Node(270);
 
 
    // now a new node with the value 320 is added as a left child to the left node of the previous level node
    tree.root_node.left.left = new Node(320);
 
 
    // now a new node with the value 350 is added as a right child to the right node of the previous level node
    tree.root_node.left.right = new Node(350);
 
    /*
               150
         /          \
       250         270
        /     \       /      \
      320 350  null  null
 
*/
 
 
 
    System.out.println("Printing the nodes of tree level wise :");
    System.out.println("Level order traversal : ");
    tree.printLevelOrder();
 
  }
}
// end of the BinaryTree class

Output:

Printing the nodes of tree level wise :
Level order traversal :
(level 0) 150
(level 1) 250 270
(level 2) 320 350

In the code written above, we have created a class named BinaryTree that has one another class named Node that will depict the actual node of a tree.

In the main function first, we have created a root node as an object of the class named Node having a value of 150. Then we added two nodes as the child nodes to the root having values 250, and 270. There newly added two children will be in level 1 and the root node will be in level 0. Now we added two child nodes to the first node in level 1 (i.e., node having value 250) having values 320 and 350 respectively.

And for printing the tree level-wise, we have created a function named printLevelOrder that will print the tree level-wise. After the successful creation of the tree, we have called the printLevelOrder function.

Binary Search Tree:

Binary Search Tree, also known as BST, is a binary tree extension having various restrictions.

The main constraint in the Binary Search Tree is that the value of the left child value of a node should be less than or equal to the value of the parent node, and the value of the right child value should be greater than or equal to the value of the parent node.

As the name depicts, the Binary Search Tree is best for searching operations because at each node we can determine where to move, that means if we are at a particular node and our search key has a value less than the value of that node then we need to move to left and vice-versa if the search key value is greater.

Code:

// Java program to create and level order traverse a binary search tree
 
 
 public class BinarySearchTree {
 
// A class named Node is created representing a single node of a binary search tree
class Node{
 
// The class Node has three class variables named key and left and right of int type and Node type respectively.
 
 
   // the key variable holds the actual value that is assigned to that node of the binary tree
int key;
 
// left and right variables that are of Node type will be used to store the left and right child nodes of the parent of the binary tree
Node left, right;
 
 
// a parameterized constructor is created to create and add data to the node at the same time.
public Node(int item){
 
key = item;
left = right = null;
}
}
 
 
 
// A static variable named root_node is created that will represent the node of the binary search tree
static Node root_node;
 
// A parametrized constructor of the BinaryTree class is written having the key as a parameter
BinarySearchTree()
{
root_node = null;
}
 
void insert(int key)
{
root_node = insertRec(root_node, key);
}
 
Node insertRec(Node root, int key)
{
 
//If the tree is empty, return a new node
 
if (root == null)
{
root = new Node(key);
return root;
}
 
// Otherwise, recur down the tree
if (key < root.key)
root.left = insertRec(root.left, key);
else if (key > root.key)
root.right = insertRec(root.right, key);
 
// return the (unchanged) node pointer
return root;
}
 
 
 
// a public static function named printLevelOrder is created to print all the nodes in the tree level-wise starting from the root node
 
public static void printLevelOrder()
    {
        int h = height(root_node);
        int i;
        for (i=1; i<=h; i++){
            printCurrentLevel(root_node, i);
            System.out.println();
          }
    }
 
// a public static function named height is created to fund the height of the binary tree starting from the root node to the farthest leaf node that is present in the tree
 
// the root node of the binary tree is passed as a parameter to the public static function named height
 
    public static int height(Node root){
 
        if (root == null)
           return 0;
        else
        {
            /* compute  height of each subtree */
            int lheight = height(root.left);
            int rheight = height(root.right);
             
            /* use the larger one */
            if (lheight > rheight)
                return(lheight+1);
            else return(rheight+1);
        }
    }
 
 
// a Public static function named printCurrrntLevel is created to print all the nodes that are present in that level
 
// this function is called repeatedly for each level of the tree
 
   public static void printCurrentLevel (Node root ,int level)
    {
        if (root == null)
            return;
        if (level == 1)
            System.out.print(root.key + " ");
        else if (level > 1)
        {
            printCurrentLevel(root.left, level-1);
            printCurrentLevel(root.right, level-1);
        }
    }
 
 
 
 
 
 
//the main function is created to create an object of the BinaryTree class and call the printLevelOrder method to level-wise print the nodes of the tree
public static void main(String[] args){
 
 
// first of all we have created an Object of the BinarySearchTree class that will represent the binary search tree
BinarySearchTree tree = new BinarySearchTree();
 
/* Let us create following BST
     50
/  \
            30          70
           /   \  /   \
        20   40      60  80
*/
tree.insert(50);
tree.insert(30);
tree.insert(20);
tree.insert(40);
tree.insert(70);
tree.insert(60);
tree.insert(80);
 
 
System.out.println("Printing the nodes of tree level wise :");
     System.out.println("Level order traversal : ");
tree.printLevelOrder();
 
}
}
// end of BinarySearchTree class

Output:

Printing the nodes of tree level wise :
Level order traversal :
(level 0) 50
(level 1) 30 70
(level 2) 20 40 60 80

In the code written above, a binary search tree with a root node having value 50 is created and then one left child and right child with values 30 and 70 are added to it respectively. Then we added one left child and right child with values 20 and 40 to the left child in level1 and after that, we added one left child and right child with values 60 and 80 to the right child of the root node in level1.

And for printing the tree level-wise, we have created a function named printLevelOrder that will print the tree level-wise. After the successful creation of the tree, we have called the printLevelOrder function.

AVL Tree:

AVL tree can be defined as a self-balancing binary search tree. The name AVL is given on behalf of the inventors Adelson-Velshi and Landis. The AVL tree has the property to balance the nodes of the tree dynamically. An additional metric named the balancing factor is added that determines whether the tree or subtree needs to be balanced or not for each node in the AVL tree. The height of the node is at most 1. In the AVL tree, the correct balance factor is 1, 0, and -1. If the tree has a new node, it will be rotated to ensure that it is balanced.

Various operations like viewing, insertion, and removal take O(log n) time in the AVL tree. It is mostly applied when working with Lookups operations.

Code:

// Java program to create and level order traverse a AVL tree
 
 
 
// A class named Node is created representing a single node of a tree
class Node {
 
// The class Node has three class variables named key and left and right of int type and Node type respectively.
 
   // the key variable holds the actual value that is assigned to that node of the tree
int key, height;
Node left, right;
 
Node(int d) {
key = d;
height = 1;
}
}// end of Node class
 
 
 
public class AVLTree {
 
// A static variable named root_node is created that will represent the node of the tree
static Node root_node;
 
// A function named height is written to get the height of the tree
int height(Node N) {
if (N == null)
return 0;
 
return N.height;
}
 
// A utility function to get maximum of two integers
int max(int a, int b) {
return (a > b) ? a : b;
}
 
Node rightRotate(Node y) {
Node x = y.left;
Node T2 = x.right;
 
x.right = y;
y.left = T2;
 
y.height = max(height(y.left), height(y.right)) + 1;
x.height = max(height(x.left), height(x.right)) + 1;
 
// Return new root
return x;
}
 
 
// A utility function to left rotate subtree rooted with x
Node leftRotate(Node x) {
Node y = x.right;
Node T2 = y.left;
 
// Perform rotation
y.left = x;
x.right = T2;
 
// Update heights
x.height = max(height(x.left), height(x.right)) + 1;
y.height = max(height(y.left), height(y.right)) + 1;
 
// Return new root
return y;
}
 
 
// Get Balance factor of node N
int getBalance(Node N) {
if (N == null)
return 0;
 
return height(N.left) - height(N.right);
}
 
 
// insert fucntion to add node(s) to the AVL
Node insert(Node node, int key) {
 
// Perform the normal BST insertion
if (node == null)
return (new Node(key));
 
if (key < node.key)
node.left = insert(node.left, key);
else if (key > node.key)
node.right = insert(node.right, key);
else // Duplicate keys not allowed
return node;
 
// Update height of this ancestor node
node.height = 1 + max(height(node.left),
height(node.right));
 
// Get the balance factor of this ancestor node to check whether this node became unbalanced
int balance = getBalance(node);
 
// If this node becomes unbalanced, then there are 4 cases Left Left Case
if (balance > 1 && key < node.left.key)
return rightRotate(node);
 
// Right Right Case
if (balance < -1 && key > node.right.key)
return leftRotate(node);
 
// Left Right Case
if (balance > 1 && key > node.left.key) {
node.left = leftRotate(node.left);
return rightRotate(node);
}
 
// Right Left Case
if (balance < -1 && key < node.right.key) {
node.right = rightRotate(node.right);
return leftRotate(node);
}
 
return node;
}
 
 
 
 
// a public static function named printLevelOrder is created to print all the nodes in the tree level-wise starting from the root node
public static void printLevelOrder()
     {
        int h = height_tree(root_node);
        int i;
        for (i=1; i<=h; i++){
            printCurrentLevel(root_node, i);
            System.out.println();
          }
    }
 
// a public static function named height is created to fund the height of the binary tree starting from the root node to the farthest leaf node that is present in the tree
// the root node of the binary tree is passed as a parameter to the public static function named height
    public static int height_tree(Node root){
 
        if (root == null)
           return 0;
        else
        {
            /* compute  height of each subtree */
            int lheight = height_tree(root.left);
            int rheight = height_tree(root.right);
             
            /* use the larger one */
            if (lheight > rheight)
                return(lheight+1);
            else return(rheight+1);
        }
    }
 
 
// a Public static function named printCurrrntLevel is created to print all the nodes that are present in that level
// this function is called repeatedly for each level of the binary tree
    public static void printCurrentLevel (Node root ,int level)
    {
        if (root == null)
            return;
        if (level == 1)
            System.out.print(root.key + " ");
        else if (level > 1)
        {
            printCurrentLevel(root.left, level-1);
            printCurrentLevel(root.right, level-1);
        }
    }
 
 
 
    //the main function is created to create an object of the BinaryTree class and call the printLevelOrder method to level-wise print the nodes of the binary tree
public static void main(String[] args) {
AVLTree tree = new AVLTree();
 
tree.root_node = tree.insert(tree.root_node, 24);
tree.root_node = tree.insert(tree.root_node, 87);
tree.root_node = tree.insert(tree.root_node, 45);
tree.root_node = tree.insert(tree.root_node, 12);
tree.root_node = tree.insert(tree.root_node, 33);
tree.root_node = tree.insert(tree.root_node, 94);
 
/* The resultant AVL Tree is
45
/  \
        24   87
        /  \     \
     12  33  94
*/
 
System.out.println("Printing the nodes of tree level wise :");
     System.out.println("Level order traversal : ");
 
tree.printLevelOrder();
}
}

Output:

Printing the nodes of tree-level wise :
Level order traversal :
45
24 87
12 33 94

Red Black Tree:

Just like AVL, red-black tree is also a type of auto-balancing tree. The name red-black is given because each node is a particular color either red or black depending upon some conditions. As it is a self-balancing tree, it maintains the overall balance of the tree. The searching operation only takes O (log n) time on the AVL tree. The addition of new nodes in the Red-Black Tree results in the rotation of the existing nodes to maintain the Red-Black Tree's properties.

Code:

// Java program to create and level order traverse a Reb-black tree
 
import static java.lang.Integer.max;
 
// A public class named RBTree is created
public class RBTree {
TreeNode Root = null;
 
 
// Function named HeightT is created to get the Height of the tree
int HeightT(TreeNode Root){
int lefth, righth;
 
if (Root == null
|| (Root.children == null
&& Root.children[1] == null)) {
return 0;
}
lefth = HeightT(Root.children[0]);
righth = HeightT(Root.children[1]);
 
return (max(lefth, righth) + 1);
}
 
// Function named check is written to check whether dir is empty or not
int check(int dir){
 
return dir == 0 ? 1 : 0;
}
 
// Function named isRed is written to check whether color of the node is red or not
boolean isRed(TreeNode Node){
 
return Node != null
&& Node.color.equals("R");
}
 
// Function named SingleRotate is written to do single rotation
TreeNode SingleRotate(TreeNode Node,int dir){
 
TreeNode temp
= Node.children[check(dir)];
Node.children[check(dir)]
= temp.children[dir];
temp.children[dir] = Node;
Root.color = "R";
temp.color = "B";
 
return temp;
}
 
// Function named DoubleRotate is written to do Double rotation
TreeNode DoubleRotate(TreeNode Node,int dir){
 
Node.children[check(dir)]= SingleRotate(Node.children[check(dir)],check(dir));
return SingleRotate(Node, dir);
}
 
// To add a new node to the tree a fucntion named Insert is written
TreeNode Insert(RBTree tree,String data){
 
if (tree.Root == null) {
tree.Root= new TreeNode(data);
if (tree.Root == null)
return null;
}
else {
 
// A temporary root
TreeNode temp = new TreeNode("");
 
// Grandparent and Parent
TreeNode g, t;
TreeNode p, q;
 
int dir = 0, last = 0;
 
t = temp;
 
g = p = null;
 
t.children[1] = tree.Root;
 
q = t.children[1];
while (true) {
 
if (q == null) {
 
// Inserting root node
q = new TreeNode(data);
p.children[dir] = q;
}
 
// Sibling is red
else if (isRed(q.children[0])
&& isRed(q.children[1])) {
 
// Recoloring if both
// children are red
q.color = "R";
q.children[0].color = "B";
q.children[1].color = "B";
}
 
if (isRed(q) && isRed(p)) {
 
// Resolving red-red
// violation
int dir2;
if (t.children[1] == g) {
dir2 = 1;
}
else {
dir2 = 0;
}
 
// If children and parent
// are left-left or
// right-right of grand-parent
if (q == p.children[last]) {
t.children[dir2]= SingleRotate(g,last == 0? 1: 0);
}
 
// If they are opposite
// childs i.e left-right
// or right-left
else {
t.children[dir2]= DoubleRotate(g,last == 0? 1: 0);
}
}
 
// Checking for correct
// position of node
if (q.data.equals(data)) {
break;
}
last = dir;
 
// Finding the path to
// traverse [Either left
// or right ]
dir = q.data.compareTo(data) < 0? 1: 0;
 
if (g != null) {
t = g;
}
 
// Rearranging pointers
g = p;
p = q;
q = q.children[dir];
}
 
tree.Root = temp.children[1];
}
 
// Black color is assigned to the root node
tree.Root.color = "B";
 
return tree.Root;
}
 
 
/////////////PRINTING A TREE/////////////////////
 
 
 
// a public function named printLevelOrder is created to print all the nodes in the tree level-wise starting from the root node
public void PrintLevel(TreeNode root, int i){
 
if (root == null) {
return;
}
 
if (i == 1) {
System.out.print("| "+ root.data+ " | "+ root.color+ " |");
 
if (root.children[0] != null) {
System.out.print(" "+ root.children[0].data+ " |");
}
else {
System.out.print(" "+ "NULL"+ " |");
}
 
 
if (root.children[1] != null) {
System.out.print(" "+ root.children[1].data+ " |");
}
else {
System.out.print(" "+ "NULL"+ " |");
}
 
System.out.print(" ");
 
return;
}
 
PrintLevel(root.children[0],
i - 1);
PrintLevel(root.children[1],
i - 1);
}
 
 
 
// A utility fucntion named LevelOrder is written to print the tree
void LevelOrder(TreeNode root){
 
int i;
 
for (i = 1;i < HeightT(root) + 1;i++){
 
PrintLevel(root, i);
System.out.print("\n\n");
}
}
}
 
 
// A class named TreeNode is created representing a single node of a tree
class TreeNode {
 
// Class variables
String data, color;
TreeNode children[];
 
public TreeNode(String data){
 
// Color R- Red
// and B - Black
this.data = data;
this.color = "R";
children
= new TreeNode[2];
children[0] = null;
children[1] = null;
}
} // end of the TreeNode class
 
// Main Class
class Main{
 
 
 
//the main function is created to create an object of the RBTree class and call the printLevelOrder method to level-wise print the nodes of the tree
public static void main(String ... nk)
{
// Representation of a Node is like:
// -------------------------------------------
// DATA | COLOR | LEFT CHILD | RIGHT CHILD |
// -------------------------------------------
 
RBTree Tree = new RBTree();
String Sentence, Word;
Sentence = "ONE TWO THREE FOUR";
String arr[] = Sentence.split(" ");
 
for (int i = 0;i < arr.length;i++) {
Tree.Root = Tree.Insert(Tree, arr[i]);
}
 
System.out.println("Printing the nodes of tree level wise :");
     System.out.println("Level order traversal : ");
System.out.println("");
Tree.LevelOrder(Tree.Root);
}
 
}// end of the Main class

Output:

Printing the nodes of tree level wise :
Level order traversal :
 
| THREE | B | ONE | TWO |
 
| ONE | B | FOUR | NULL | | TWO | B | NULL | NULL |
 
| FOUR | R | NULL | NULL |

So, in the above code, we have successfully implemented a Red-Black tree with the insert and traversal operation. In the output, the data printed is in the order

Data in the node
Color of that node
Left Child of that particular node
Right Child of that particular node

If the right child node or the left child node of a tree is NULL that means that particular nodes either don't have the right child or left child respectively.

N-ary Tree:

In the N-ary tree, the maximum number of child nodes that can be associated with the preceding parent node is N. A N-ary Tree is very similar to the general or generic tree which can also have any number of nodes in the tree.

The implementation of the N-ary Tree is exactly the same as the General tree in the java programming language.

So, in this article, we get a clear idea about the different types of trees and we have seen each one of them in brief for a better understanding. We have also implemented a sample java code for all of these types of trees like General Tree, Binary Tree, Binary Search Tree, AVL Tree, Red-Black Tree, and N-ary Tree.

Next TopicAbstract data type in data structure

← prev next →