Binary Tree Java

Binary tree is a tree type non-linear data structure that are mainly used for sorting and searching because they store data in hierarchical form. In this section, we will learn the implementation of binary tree data structure in Java. Also, provides a short description of binary tree data structure.

Binary Tree

A tree in which each node (parent) has at most two-child nodes (left and right) is called binary tree. The top most node is called the root node. In a binary tree a node contains the data and the pointer (address) of the left and right child node.

The height of a binary tree is the number of edges between the tree's root and its furthest (deepest) leaf. If the tree is empty, the height is 0. The height of the node is denoted by h.

The height of the above binary tree is 2.

We can calculate the number of leaves and node by using the following formula.

Maximum number of leaf nodes is a binary tree: 2^h
Maximum number of nodes is a binary tree: 2^h+1-1

Where, h is the height of binary tree.

Example of Binary Tree

Types of Binary Tree

There are the following types of binary tree in data structure:

Full/ Strictly Binary Tree
Complete Binary Tree
Perfect Binary Tree
Balance Binary Tree
Rooted Binary Tree
Degenerated/ Pathological Binary Tree
Extended Binary Tree
Skewed Binary Tree
1. Left-skewed Binary Tree
2. Right-skewed Binary Tree
Threaded Binary Tree
1. Single Threaded Binary Tree
2. Double Threaded Binary Tree
AVL Tree
Red Black Tree
B Tree
B+ Tree
Segment Tree

Binary Tree Implementation in Java

There are many ways to implement binary tree. In this section, we will implement binary tree using LinkedList data structure. Along with it, we will also implement the traversal orders, searching a node and insert a node in a binary tree.

Implementation of Binary Tree Using LinkedList

Algorithm

Define Node class that contains three attributes namely: data left and right. Here, left represents the left child of the node and right represents the right child of the node.

When a node is created, data will pass to data attribute of the node and both left and right will be set to null.
Define another class that has an attribute root.
Root represents the root node of the tree and initialize it to null.

insert() will add a new node to the tree:
- It checks whether the root is null, which means the tree is empty. It will add the new node as root.
- Else, it will add root to the queue.
- The variable node represents the current node.
- First, it checks whether a node has a left and right child. If yes, it will add both nodes to queue.
- If the left child is not present, it will add the new node as the left child.
- If the left is present, then it will add the new node as the right child.
inorder() will display nodes of the tree in inorder fashion.
- It traverses the entire tree then prints out left child followed by root then followed by the right child.

BinarySearchTree.java

public class BinarySearchTree {  
    //Represent the node of binary tree  
    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;  
            }  
        }  
    //Represent the root of binary tree  
    public Node root;  
    public BinarySearchTree(){  
        root = null;  
    }  
    //factorial() will calculate the factorial of given number  
    public int factorial(int num) {  
        int fact = 1;  
        if(num == 0)  
            return 1;  
        else {  
            while(num > 1) {  
                fact = fact * num;  
                num--;  
            }  
            return fact;  
        }  
    }  
    //numOfBST() will calculate the total number of possible BST by calculating Catalan Number for given key  
    public int numOfBST(int key) {  
        int catalanNumber = factorial(2 * key)/(factorial(key + 1) * factorial(key));  
        return catalanNumber;  
    }  
    public static void main(String[] args) {  
        BinarySearchTree bt = new BinarySearchTree();  
        //Display total number of possible binary search tree with key 5  
        System.out.println("Total number of possible Binary Search Trees with given key: " + bt.numOfBST(5));  
      }  
}  

Output:

Binary tree after insertion
1 
Binary tree after insertion
2 1 3 
Binary tree after insertion
4 2 5 1 3 
Binary tree after insertion
4 2 5 1 6 3 7

Binary Tree Operations

The following operations can be performed on a binary tree:

Insertion: Adding a new node to the tree.
Deletion: Removing a node from the tree.
Traversal:
1. In-order Traversal: Visit left subtree, then current node, then right subtree.
2. Pre-order Traversal: Visit current node, then left subtree, then right subtree.
3. Post-order Traversal: Visit left subtree, then right subtree, then current node.
4. Level Order Traversal: Visit nodes level by level, from left to right.
Search: Finding a specific node with a given value.

Java Program to Insert a Node in Binary Tree

BinaryTreeInsert.java

public class BinaryTreeInsert 
{
    public static void main(String[] args) 
    {
        new BinaryTreeInsert().run();
    }
    static class Node 
    {
        Node left;
        Node right;
        int value;
        public Node(int value) 
        {
            this.value = value;
        }
    }
    public void run() 
    {
        Node rootnode = new Node(25);
        System.out.println("Building tree with root value " + rootnode.value);
        System.out.println("=================================");
        insert(rootnode, 11);
        insert(rootnode, 15);
        insert(rootnode, 16);
        insert(rootnode, 23);
        insert(rootnode, 79);
    }
    public void insert(Node node, int value) 
    {
        if (value < node.value) 
        {
            if (node.left != null) 
            {
                insert(node.left, value);
            } else 
            {
                System.out.println("  Inserted " + value + " to left of Node " + node.value);
                node.left = new Node(value);
            }
        } 
        else if (value > node.value) 
        {
            if (node.right != null) 
            {
                insert(node.right, value);
            } else 
            {
                System.out.println("  Inserted " + value + " to right of Node " + node.value);
                node.right = new Node(value);
            }
        }
    }
}

Output:

Building tree with root value 25
=================================
  Inserted 11 to left of Node 25
  Inserted 15 to right of Node 11
  Inserted 16 to right of Node 15
  Inserted 23 to right of Node 16
  Inserted 79 to right of Node 25

Java Program to Delete a Node in Java

Algorithm

Starting at the root, find the deepest and rightmost node in binary tree and node that we want to delete.
Replace the deepest rightmost node's data with the node to be deleted.
Then delete the deepest rightmost node.

Consider the following figure.

DeleteNode.java

import java.util.LinkedList;
import java.util.Queue;
public class DeleteNode 
{
// A binary tree node has key, pointer to
// left child and a pointer to right child
static class Node
{
	int key;
	Node left, right;
	
	// Constructor
	Node(int key)
	{
		this.key = key;
		left = null;
		right = null;
	}
}
static Node root;
static Node temp = root;
// Inorder traversal of a binary tree
static void inorder(Node temp)
{
	if (temp == null)
		return;
	inorder(temp.left);
	System.out.print(temp.key + " ");
	inorder(temp.right);
}
// Function to delete deepest
// element in binary tree
static void deleteDeepest(Node root, Node delNode)
{
	Queue<node> q = new LinkedList<node>();
	q.add(root);
	Node temp = null;
	// Do level order traversal until last node
	while (!q.isEmpty())
	{
		temp = q.peek();
		q.remove();
		
		if (temp == delNode)
		{
			temp = null;
			return;
		}
		if (temp.right!=null)
		{
			if (temp.right == delNode)
			{
				temp.right = null;
				return;
		}
		else
			q.add(temp.right);
	}
	if (temp.left != null)
	{
		if (temp.left == delNode)
		{
			temp.left = null;
			return;
		}
		else
			q.add(temp.left);
	}
}
}
// Function to delete given element
// in binary tree
static void delete(Node root, int key)
{
	if (root == null)
		return;
		
	if (root.left == null &&
	root.right == null)
	{
		if (root.key == key)
		{
			root=null;
			return;
		}
		else
			return;
	}
	Queue<node> q = new LinkedList<node>();
	q.add(root);
	Node temp = null, keyNode = null;
	// Do level order traversal until
	// we find key and last node.
	while (!q.isEmpty())
	{
		temp = q.peek();
		q.remove();
		if (temp.key == key)
			keyNode = temp;
		if (temp.left != null)
			q.add(temp.left);
		if (temp.right != null)
			q.add(temp.right);
	}
	if (keyNode != null)
	{
		int x = temp.key;
		deleteDeepest(root, temp);
		keyNode.key = x;
	}
}
// Driver code
public static void main(String args[])
{
	root = new Node(10);
	root.left = new Node(11);
	root.left.left = new Node(7);
	root.left.right = new Node(12);
	root.right = new Node(9);
	root.right.left = new Node(15);
	root.right.right = new Node(8);
	System.out.print("Inorder traversal before deletion: ");
	inorder(root);
	//node to delete
	int key = 7;
	delete(root, key);
	System.out.print("\nInorder traversal after deletion: ");
	inorder(root);
}
}
</node></node></node></node>

Output:

Inorder traversal before deletion: 7 11 12 10 15 9 8 
Inorder traversal after deletion: 8 11 12 10 15 9

Java Program to Search a Node in Binary Tree

Algorithm

Define Node class which has three attributes namely: data left and right. Here, left represents the left child of the node and right represents the right child of the node.
When a node is created, data will pass to data attribute of the node and both left and right will be set to null.
Define another class which has two attribute root and flag.
1. Root represents the root node of the tree and initializes it to null.
2. The Flag will be used to check whether the given node is present in the tree or not. Initially, it will be set to false.

searchNode() will search for a particular node in the binary tree:
- It checks whether the root is null, which means the tree is empty.
- If the tree is not empty, it will compare temp's data with value. If they are equal, it will set the flag to true and return.
- Traverse left subtree by calling searchNode() recursively and check whether the value is present in left subtree.
- Traverse right subtree by calling searchNode() recursively and check whether the value is present in the right subtree.

SearchBinaryTree.java

public class SearchBinaryTree 
{  
      //Represent a node of binary tree  
      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;  
        }  
      }  
      //Represent the root of binary tree  
      public Node root;  
      public static boolean flag = false;  
      public SearchBinaryTree()
      {  
        root = null;  
      }  
      //searchNode() will search for the particular node in the binary tree  
      public void searchNode(Node temp, int value)
      {  
        //Check whether tree is empty  
        if(root == null)
        {  
          System.out.println("Tree is empty");  
        }  
        else
        {  
          //If value is found in the given binary tree then, set the flag to true  
          if(temp.data == value)
          {  
            flag = true;  
               return;  
          }  
          //Search in left subtree  
          if(flag == false && temp.left != null)
          {  
          searchNode(temp.left, value);  
          }  
          //Search in right subtree  
          if(flag == false && temp.right != null)
          {  
          searchNode(temp.right, value);  
          }  
        }  
      }  
      public static void main(String[] args) 
      {  
        SearchBinaryTree bt = new SearchBinaryTree();  
        //Add nodes to the binary tree  
        bt.root = new Node(11);  
        bt.root.left = new Node(8);  
        bt.root.right = new Node(12);  
        bt.root.left.left = new Node(78);  
        bt.root.right.left = new Node(23);  
        bt.root.right.right = new Node(36);  
        //Search for node 5 in the binary tree  
           bt.searchNode(bt.root, 23);  
        if(flag)  
          System.out.println("Element is present in the binary tree.");  
        else  
          System.out.println("Element is not present in the binary tree.");  
      }  
    }  

Output:

Element is present in the binary tree.

Binary Tree Traversal

Traversal Order	First Visit	Second Visit	Third Visit
Inorder	Visit left subtree in inorder	Visit root node	Visit right subtree in inorder
Preorder	Visit root node	Visit left subtree in preorder	Visit right subtree in preorder
Postorder	Visit left subtree in postorder	Visit right subtree in postorder	Visit root node

Note: Except the above three traversals, there is another traversal order is called boundary traversal.

Java Program to Traverse Inorder, Preorder, and Postorder Traversal

BinaryTree.java

public class BinaryTree 
{
  // first node
  private Node root;
  BinaryTree()
  {
    root = null;
  }
  // Class representing tree nodes
  static class Node
  {
    int value;
    Node left;
    Node right;
    Node(int value)
    {
      this.value = value;
      left = null;
      right = null;        
    }
    public void displayData()
    {
      System.out.print(value + " ");
    }
  }
    
  public void insert(int i)
  {
    root = insert(root, i);
  }
  //Inserting node - recursive method
  public Node insert(Node node, int value)
  {
    if(node == null){
      return new Node(value);
    }
    // Move to the left if passed value is 
    // less than the current node
    if(value < node.value)
    {
      node.left = insert(node.left, value);
    }
    // Move to the right if passed value is 
    // greater than the current node
    else if(value > node.value)
    {
      node.right = insert(node.right, value);
    }
    return node;
  }
  // Search node in binary search tree
  public Node find(int searchedValue)
  {
    Node current = root;
    while(current.value != searchedValue)
    {
      if(searchedValue < current.value)
        // Move to the left if searched value is less
        current = current.left;
      else
        // Move to the right if searched value is >=
        current = current.right;
      if(current == null)
      {
        return null;
      }
    }
    return current;
  }
  // For traversing in order
  public void inOrder(Node node)
  {
    if(node != null)
    {
      inOrder(node.left);
      node.displayData();
      inOrder(node.right);
    }
  }
  // Preorder traversal
  public void preOrder(Node node)
  {
    if(node != null){
      node.displayData();
      preOrder(node.left);           
      preOrder(node.right);
    }
  }
  // Postorder traversal
  public void postOrder(Node node)
  {
    if(node != null)
    {
      postOrder(node.left);
      postOrder(node.right);
      node.displayData();          
    }
  }
  public static void main(String[] args) 
  {
    BinaryTree bst = new BinaryTree();
    bst.insert(34);
    bst.insert(56);
    bst.insert(12);
    bst.insert(89);
    bst.insert(67);
    bst.insert(90);
    System.out.println("Inorder traversal of binary tree");
    bst.inOrder(bst.root);
    System.out.println();
    System.out.println("Preorder traversal of binary tree");
    bst.preOrder(bst.root);
    System.out.println();
    System.out.println("Postorder traversal of binary tree");
    bst.postOrder(bst.root);
    System.out.println();
  }
}

Output:

Inorder traversal of binary tree
12 34 56 67 89 90 
Preorder traversal of binary tree
34 12 56 89 67 90 
Postorder traversal of binary tree
12 67 90 89 56 34

Besides the above operations, we can also perform the operations such as large node, smallest node, and sum of all nodes.

Java Program to Find the Largest Node in Binary Tree

LargestNode.java

public class LargestNode 
{  
    //Represent the node of binary tree  
    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;  
        }  
     }  
      //Represent the root of binary tree  
      public Node root;  
      public LargestNode()
      {  
        root = null;  
      }  
      //largestElement() will find out the largest node in the binary tree  
      public int largestElement(Node temp)
      {  
          //Check whether tree is empty  
           if(root == null) 
           {  
               System.out.println("Tree is empty");  
               return 0;  
            }  
           else
           {  
               int leftMax, rightMax;  
               //Max will store temp's data  
               int max = temp.data;  
               //It will find largest element in left subtree  
               if(temp.left != null){  
                   leftMax = largestElement(temp.left);  
                   //Compare max with leftMax and store greater value into max  
                   max = Math.max(max, leftMax);  
                }  
                //It will find largest element in right subtree  
                if(temp.right != null){  
                    rightMax = largestElement(temp.right);  
                    //Compare max with rightMax and store greater value into max  
                    max = Math.max(max, rightMax);  
                }  
                return max;  
           }  
      }  
      public static void main(String[] args) 
      {  
        LargestNode bt = new LargestNode();  
        //Add nodes to the binary tree  
        bt.root = new Node(90);  
        bt.root.left = new Node(99);  
        bt.root.right = new Node(23);  
        bt.root.left.left = new Node(96);  
        bt.root.right.left = new Node(45);  
        bt.root.right.right = new Node(6);  
         bt.root.right.left = new Node(13);  
         bt.root.right.right = new Node(77);  
        //Display largest node in the binary tree  
        System.out.println("Largest element in the binary tree: " + bt.largestElement(bt.root));  
      }  
}  

Output:

Largest element in the binary tree: 99

Java Program to Find the Smallest Node in Binary Tree

Algorithm

Define Node class which has three attributes namely: data, left and right. Here, left represents the left child of the node and right represents the right child of the node.
When a node is created, data will pass to data attribute of node and both left and right will be set to null.
Define another class which has an attribute root.
1. Root represent root node of the tree and initialize it to null.

smallestElement() will find out the smallest node in binary tree:
1. It checks whether root is null, which means tree is empty.
2. If tree is not empty, define a variable min that will store temp's data.
3. Find out the minimum node in left subtree by calling smallestElement() recursively. Store that value in leftMin. Compare the value of min with leftMin and store the minimum of two to min.
4. Find out the minimum node in right subtree by calling smallestElement() recursively. Store that value in rightMin. Compare the value of min with rightMin and store the maximum of two to min.
5. At the end, min will hold the smallest node in the binary tree.

SmallestNode.java

public class SmallestNode 
{  
      //Represent the node of binary tree  
      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;  
        }  
      }  
      //Represent the root of binary tree  
      public Node root;  
      public SmallestNode()
      {  
          root = null;  
      }  
      //smallestElement() will find out the smallest node in the binary tree  
      public int smallestElement(Node temp)
      {  
          //Check whether tree is empty  
          if(root == null) 
          {  
              System.out.println("Tree is empty");  
              return 0;  
          }  
          else 
          {  
                int leftMin, rightMin;  
                //Min will store temp's data  
                int min = temp.data;  
                //It will find smallest element in left subtree  
                if(temp.left != null)
                {  
                  leftMin = smallestElement(temp.left);  
                  //If min is greater than leftMin then store the value of leftMin into min  
                  min = Math.min(min, leftMin);  
                }  
                //It will find smallest element in right subtree  
                if(temp.right != null)
                {  
                  rightMin = smallestElement(temp.right);  
                  //If min is greater than rightMin then store the value of rightMin into min  
                  min = Math.min(min, rightMin);  
                }  
                return min;  
          }  
      }  
      public static void main(String[] args) {  
        SmallestNode bt = new SmallestNode();  
        //Add nodes to the binary tree  
        bt.root = new Node(9);  
        bt.root.left = new Node(5);  
        bt.root.right = new Node(7);  
        bt.root.left.left = new Node(1);  
        bt.root.right.left = new Node(2);  
        bt.root.right.right = new Node(8);  
        bt.root.right.left = new Node(4);  
        bt.root.right.right = new Node(3);  
        //Display smallest node in the binary tree  
        System.out.println("Smallest element in the binary tree: " + bt.smallestElement(bt.root));  
      }  
}  

Output:

Smallest element in the binary tree: 1

Java Program to Find the Maximum Width of a Binary Tree

Algorithm

Define Node class which has three attributes namely: data left and right. Here, left represents the left child of the node and right represents the right child of the node.
When a node is created, data will pass to data attribute of the node and both left and right will be set to null.
Define another class which has an attribute root.
1. Root represents the root node of the tree and initializes it to null.
findMaximumWidth() will find out the maximum width of the given binary tree:
1. Variable maxWidth will store the maximum number of nodes present in any level.
2. The queue is used for traversing binary tree level-wise.
3. It checks whether the root is null, which means the tree is empty.
4. If not, add the root node to queue. Variable nodesInLevel keeps track of the number of nodes in each level.
5. If nodesInLevel > 0, remove the node from the front of the queue and add its left and right child to the queue. For the first iteration, node 1 will be removed and its children nodes 2 and 3 will be added to the queue. In the second iteration, node 2 will be removed, its children 4 and 5 will be added to the queue and so on.
6. MaxWidth will store max(maxWidth, nodesInLevel). So, at any given point of time, it will represent the maximum number of nodes.
7. This will continue till all the levels of the tree is traversed.

BinaryTree.java

import java.util.LinkedList;  
import java.util.Queue;  
   
public class BinaryTree 
{  
    //Represent the node of binary tree  
      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;  
        }  
      }  
      //Represent the root of binary tree  
      public Node root; 
      public BinaryTree()
      {  
        root = null;  
      }  
//findMaximumWidth() will find out the maximum width of the given binary tree  
      public int findMaximumWidth() 
      {  
          int maxWidth = 0;  
          //Variable nodesInLevel keep tracks of number of nodes in each level  
          int nodesInLevel = 0;  
          //queue will be used to keep track of nodes of tree level-wise  
          Queue<node> queue = new LinkedList<node>();  
          //Check if root is null, then width will be 0  
          if(root == null) {  
              System.out.println("Tree is empty");  
              return 0;  
          }  
          else 
          {  
              //Add root node to queue as it represents the first level  
              queue.add(root); 
              while(queue.size() != 0) 
              {  
                  //Variable nodesInLevel will hold the size of queue i.e. number of elements in queue  
                  nodesInLevel = queue.size();  
                  //maxWidth will hold maximum width.   
                  //If nodesInLevel is greater than maxWidth then, maxWidth will hold the value of nodesInLevel  
                  maxWidth = Math.max(maxWidth, nodesInLevel);  
                  //If variable nodesInLevel contains more than one node   
                  //then, for each node, we'll add left and right child of the node to the queue  
                  while(nodesInLevel > 0) 
                  {  
                     Node current = queue.remove();  
                     if(current.left != null)   
                         queue.add(current.left);  
                     if(current.right != null)   
                         queue.add(current.right);  
                     nodesInLevel--;  
                  }  
              }  
          }  
          return maxWidth;  
      }  
      public static void main(String[] args) 
      {  
          BinaryTree bt = new BinaryTree();  
          //Add nodes to the binary tree  
          bt.root = new Node(1);  
          bt.root.left = new Node(2);  
          bt.root.right = new Node(3);  
          bt.root.left.left = new Node(4);  
          bt.root.left.right = new Node(5);  
          bt.root.right.left = new Node(6);  
          bt.root.right.right = new Node(7);  
          bt.root.left.left.left = new Node(8);  
          //Display the maximum width of given tree  
          System.out.println("Maximum width of the binary tree: " + bt.findMaximumWidth());  
      }  
}  
</node></node>

Output:

Maximum width of the binary tree: 4

Find Maximum Element of the Binary Tree

Finding the maximum element of a Binary Tree involves recursively comparing values in the tree nodes to determine the highest value. It is essential for various algorithms, aiding in efficient search operations and understanding the tree's structure.

BinaryTreeMaxElement.java

// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the maximum element in a binary tree
public class BinaryTreeMaxElement {
    // Method to find the maximum element in the binary tree
    public int findMax(TreeNode root) {
        // Base case: if the root is null, return the minimum possible value
        if (root == null)
            return Integer.MIN_VALUE;
        // Recursively find the maximum value in left and right subtrees
        int leftMax = findMax(root.left);   // Maximum value in the left subtree
        int rightMax = findMax(root.right); // Maximum value in the right subtree
        // Compare the root's value with the maximum values from left and right subtrees
        int max = Math.max(root.val, Math.max(leftMax, rightMax)); // Overall maximum value in the tree
        return max; // Return the maximum value found
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);         // Root node with value 1
        root.left = new TreeNode(3);             // Left child of root with value 3
        root.right = new TreeNode(2);            // Right child of root with value 2
        root.left.left = new TreeNode(4);       // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);      // Right child of node with value 3, value 5
        BinaryTreeMaxElement solution = new BinaryTreeMaxElement(); // Create an instance of BinaryTreeMaxElement
        int maxElement = solution.findMax(root); // Find the maximum element in the binary tree
        // Print the maximum element found
        System.out.println("Maximum element in the binary tree is: " + maxElement); // Output: 5
    }
}

Output:

Maximum element in the binary tree is: 5

Time Complexity: O(n)

Space Complexity: O(n)

Find Height of the Binary Tree

The height of a tree is a fundamental metric that measures the length of the longest path from the root to any leaf node. It quantifies the depth of the tree structure, reflecting its overall size and complexity

BinaryTreeHeight.java

// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the height of a binary tree
public class BinaryTreeHeight {
    // Method to find the height of the binary tree
    public int findHeight(TreeNode root) {
        // Base case: if the root is null, the height is 0
        if (root == null)
            return 0;
        // Recursively find the height of the left and right subtrees
        int leftHeight = findHeight(root.left);    // Height of the left subtree
        int rightHeight = findHeight(root.right);  // Height of the right subtree
        // The height of the tree is the maximum of the heights of its left and right subtrees, plus 1
        int height = Math.max(leftHeight, rightHeight) + 1;
        return height; // Return the height of the tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        BinaryTreeHeight solution = new BinaryTreeHeight();  // Create an instance of BinaryTreeHeight
        int height = solution.findHeight(root);  // Find the height of the binary tree
        // Print the height of the tree
        System.out.println("Height of the binary tree is: " + height);  // Output: 3
    }
}

Output:

Height of the binary tree is: 3

Time Complexity: O(n) where n is the number of nodes in the tree.

Auxiliary Space Complexity: O(h) where h is the height of the tree.

Find Deepest Node of the Binary Tree

Finding the deepest node of a tree involves identifying the node that is farthest from the root. This node is located at the maximum depth of the tree and has no children.

DeepestNodeInBinaryTree.java

import java.util.LinkedList;
import java.util.Queue;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the deepest node in a binary tree
public class DeepestNodeInBinaryTree {
    // Method to find the deepest node in the binary tree
    public TreeNode findDeepestNode(TreeNode root) {
        // Base case: if the root is null, return null
        if (root == null)
            return null;
        TreeNode deepestNode = null; // Initialize the variable to store the deepest node found
        Queue<treenode> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(root); // Add the root node to the queue
        // Perform level order traversal
        while (!queue.isEmpty()) {
            deepestNode = queue.poll(); // Remove and retrieve the front of the queue
            // Add left child to the queue if it exists
            if (deepestNode.left != null)
                queue.offer(deepestNode.left);
            // Add right child to the queue if it exists
            if (deepestNode.right != null)
                queue.offer(deepestNode.right);
        }
        return deepestNode; // Return the deepest node found
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        DeepestNodeInBinaryTree solution = new DeepestNodeInBinaryTree();  // Create an instance of DeepestNodeInBinaryTree
        TreeNode deepestNode = solution.findDeepestNode(root);  // Find the deepest node in the binary tree
        // Print the deepest node found
        System.out.println("Deepest node in the binary tree is: " + deepestNode.val);  // Output: 4
    }
}
</treenode>

Output:

Deepest node in the binary tree is: 5

Time Complexity: O(n)

Auxiliary Space Complexity: O(w)

Left view of the Tree

The left view of a binary tree refers to the nodes that are visible when the tree is viewed from the left-hand side. It includes the first node of each level starting from the root going to the leftmost leaf.

LeftViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the left view of a binary tree
public class LeftViewOfBinaryTree {
    // Method to get the left view of the binary tree
    public List<Integer> leftView(TreeNode root) {
        List<Integer> result = new ArrayList<>(); // List to store the left view nodes
        if (root == null)
            return result; // If the root is null, return an empty result list
        Queue<TreeNode> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(root); // Add the root node to the queue
        // Perform level order traversal
        while (!queue.isEmpty()) {
            int levelSize = queue.size(); // Number of nodes at the current level
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll(); // Remove and retrieve the front of the queue
                // Add the first node of each level to the result
                if (i == 0) {
                    result.add(node.val);
                }
                // Add left child to the queue if it exists
                if (node.left != null) {
                    queue.offer(node.left);
                }
                // Add right child to the queue if it exists
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return result; // Return the left view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5        LeftViewOfBinaryTree solution = new LeftViewOfBinaryTree();  // Create an instance of LeftViewOfBinaryTree
        List<Integer> leftView = solution.leftView(root);  // Get the left view of the binary tree
        // Print the left view of the tree
        System.out.println("Left view of the binary tree is: " + leftView);  // Output: [1, 3, 4]
    }
}

Output:

Left view of the binary tree is: [1, 3, 4]

Time Complexity: O(n) (linear, where n is the number of nodes in the binary tree)

Auxiliary Space Complexity: O(m), where m is the maximum number of nodes at any level in the binary tree

Right View of the Binary Tree

The right view of a binary tree refers to the set of nodes visible when the tree is viewed from the right side. It includes the topmost node at each level, allowing us to see the rightmost nodes of the tree at each level.

RightViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the right view of a binary tree
public class RightViewOfBinaryTree {
    // Method to get the right view of the binary tree
    public List<integer> rightView(TreeNode root) {
        List<integer> result = new ArrayList<>(); // List to store the right view nodes
        if (root == null)
            return result; // If the root is null, return an empty result list
        Queue<treenode> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(root); // Add the root node to the queue
        // Perform level order traversal
        while (!queue.isEmpty()) {
            int levelSize = queue.size(); // Number of nodes at the current level
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll(); // Remove and retrieve the front of the queue
                // Add the last node of each level to the result
                if (i == levelSize - 1) {
                    result.add(node.val);
                }
                // Add left child to the queue if it exists
                if (node.left != null) {
                    queue.offer(node.left);
                }
                // Add right child to the queue if it exists
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return result; // Return the right view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        RightViewOfBinaryTree solution = new RightViewOfBinaryTree();  // Create an instance of RightViewOfBinaryTree
        List<integer> rightView = solution.rightView(root);  // Get the right view of the binary tree
        // Print the right view of the tree
        System.out.println("Right view of the binary tree is: " + rightView);  // Output: [1, 2, 5]
    }
}
</integer></treenode></integer></integer>

Output:

Right view of the binary tree is: [1, 2, 5]

Time Complexity: O(n), where n is the number of nodes in the binary tree.

Auxiliary Space Complexity: O(m), where m is the maximum number of nodes at any level in the binary tree.

Top View of the Binary Tree

The top view of a binary tree refers to the nodes visible from the top when the tree is viewed from above. It consists of the nodes that are the first to be encountered in each vertical level, starting from the root.

TopViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the top view of a binary tree
public class TopViewOfBinaryTree {
    // Inner class to store node with its horizontal distance
    class NodeWithHD {
        TreeNode node;
        int hd; // Horizontal distance from the root
        NodeWithHD(TreeNode node, int hd) {
            this.node = node;
            this.hd = hd;
        }
    }
    // Method to get the top view of the binary tree
    public List<integer> topView(TreeNode root) {
        List<integer> result = new ArrayList<>();
        if (root == null) {
            return result; // If the root is null, return an empty result list
        }
        Map<integer , integer> topViewMap = new TreeMap<>(); // To store the first node at each horizontal distance
        Queue<nodewithhd> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(new NodeWithHD(root, 0)); // Add the root node with horizontal distance 0
        // Perform level order traversal
        while (!queue.isEmpty()) {
            NodeWithHD temp = queue.poll(); // Remove and retrieve the front of the queue
            int hd = temp.hd;
            TreeNode node = temp.node;
            // If the horizontal distance is not already present in the map, add it
            if (!topViewMap.containsKey(hd)) {
                topViewMap.put(hd, node.val);
            }
            // Add left child to the queue with horizontal distance hd-1
            if (node.left != null) {
                queue.offer(new NodeWithHD(node.left, hd - 1));
            }
            // Add right child to the queue with horizontal distance hd+1
            if (node.right != null) {
                queue.offer(new NodeWithHD(node.right, hd + 1));
            }
        }
        // Extract the top view nodes from the map
        for (Map.Entry<integer , integer> entry : topViewMap.entrySet()) {
            result.add(entry.getValue());
        }
        return result; // Return the top view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        TopViewOfBinaryTree solution = new TopViewOfBinaryTree();  // Create an instance of TopViewOfBinaryTree
        List<integer> topView = solution.topView(root);  // Get the top view of the binary tree
        // Print the top view of the tree
        System.out.println("Top view of the binary tree is: " + topView);  // Output: [4, 3, 1, 2]
    }
}
</integer></integer></nodewithhd></integer></integer></integer>

Output:

Top view of the binary tree is: [4, 3, 1, 2]

Time Complexity: O(N)

Auxiliary Space Complexity: O(N)

Bottom View of the Tree

The bottom view of a binary tree refers to the nodes visible from the bottom when the tree is viewed from the bottom up. It displays the lowest nodes of the tree, taking into account their horizontal distance from the root.

BottomViewOfBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the bottom view of a binary tree
public class BottomViewOfBinaryTree {
    // Inner class to store node with its horizontal distance
    class NodeWithHD {
        TreeNode node;
        int hd; // Horizontal distance from the root
        NodeWithHD(TreeNode node, int hd) {
            this.node = node;
            this.hd = hd;
        }
    }
    // Method to get the bottom view of the binary tree
    public List<integer> bottomView(TreeNode root) {
        List<integer> result = new ArrayList<>();
        if (root == null) {
            return result; // If the root is null, return an empty result list
        }
        Map<integer , integer> bottomViewMap = new TreeMap<>(); // To store the last node at each horizontal distance
        Queue<nodewithhd> queue = new LinkedList<>(); // Queue for level order traversal
        queue.offer(new NodeWithHD(root, 0)); // Add the root node with horizontal distance 0
        // Perform level order traversal
        while (!queue.isEmpty()) {
            NodeWithHD temp = queue.poll(); // Remove and retrieve the front of the queue
            int hd = temp.hd;
            TreeNode node = temp.node;
            // Update the node value at each horizontal distance
            bottomViewMap.put(hd, node.val);
            // Add left child to the queue with horizontal distance hd-1
            if (node.left != null) {
                queue.offer(new NodeWithHD(node.left, hd - 1));
            }
            // Add right child to the queue with horizontal distance hd+1
            if (node.right != null) {
                queue.offer(new NodeWithHD(node.right, hd + 1));
            }
        }
        // Extract the bottom view nodes from the map
        for (Map.Entry<integer , integer> entry : bottomViewMap.entrySet()) {
            result.add(entry.getValue());
        }
        return result; // Return the bottom view of the binary tree
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        BottomViewOfBinaryTree solution = new BottomViewOfBinaryTree();  // Create an instance of BottomViewOfBinaryTree
        List<integer> bottomView = solution.bottomView(root);  // Get the bottom view of the binary tree
        // Print the bottom view of the tree
        System.out.println("Bottom view of the binary tree is: " + bottomView);  // Output: [4, 3, 5, 2]
    }
}
</integer></integer></nodewithhd></integer></integer></integer>

Output:

Bottom view of the binary tree is: [4, 3, 5, 2]

Time Complexity: O(N)

Auxiliary Space Complexity: O(N)

The Mirror Image of the Tree

The mirror image of a tree, also known as the mirror tree or the inverted tree, is a binary tree that is formed by swapping the left and right children of each node in the original tree. This transformation results in a tree where the structure is reversed along the vertical axis, with each node's children mirrored.

MirrorImageOfBinaryTree.java

// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to find the mirror image of a binary tree
public class MirrorImageOfBinaryTree {
    // Method to find the mirror image of the binary tree
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null) {
            return null; // Base case: if root is null, return null
        }
        // Swap left and right subtrees recursively
        TreeNode temp = root.left;
        root.left = mirrorTree(root.right);
        root.right = mirrorTree(temp);
        return root;
    }
    // Method to print the tree using inorder traversal (for verification)
    public void printInorder(TreeNode root) {
        if (root != null) {
            printInorder(root.left);
            System.out.print(root.val + " ");
            printInorder(root.right);
        }
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        MirrorImageOfBinaryTree solution = new MirrorImageOfBinaryTree();  // Create an instance of MirrorImageOfBinaryTree
        System.out.println("Original tree:");
        solution.printInorder(root);  // Print the inorder traversal of the original tree
        System.out.println();
        TreeNode mirrorRoot = solution.mirrorTree(root);  // Get the mirror image of the binary tree
        System.out.println("Mirror image of the tree:");
        solution.printInorder(mirrorRoot);  // Print the inorder traversal of the mirror image tree
        System.out.println();
    }
}

Output:

Original tree:
4 3 5 1 2 
Mirror image of the tree:
2 1 5 3 4

Time Complexity: O(n)

Auxiliary Space Complexity: O(h)

Serialize a Binary Tree

Tree serialization involves converting a binary tree into a format that can be stored or transmitted and later reconstructed, while preserving its structure. This process typically uses a traversal method, such as preorder, and includes markers for null nodes. Below is a Java program that implements this approach:

SerializeDeserializeBinaryTree.java

import java.util.*;
// Definition of a TreeNode class
class TreeNode {
    int val;          // Value of the node
    TreeNode left;    // Left child node
    TreeNode right;   // Right child node
    // Constructor to initialize the node with a value
    TreeNode(int x) {
        val = x;
    }
}
// Class to serialize and deserialize a binary tree
public class SerializeDeserializeBinaryTree {
    // Serialize a tree to a string
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        serializeHelper(root, sb);
        return sb.toString();
    }
    // Helper function to serialize the tree
    private void serializeHelper(TreeNode root, StringBuilder sb) {
        if (root == null) {
            sb.append("null").append(" "); // Use "null" to represent null nodes
            return;
        }
        sb.append(root.val).append(" "); // Append the value of the node
        serializeHelper(root.left, sb);  // Recursively serialize the left subtree
        serializeHelper(root.right, sb); // Recursively serialize the right subtree
    }
    // Deserialize a string to a tree
    public TreeNode deserialize(String data) {
        if (data == null || data.isEmpty()) {
            return null;
        }
        Queue<string> nodes = new LinkedList<>();
        nodes.addAll(Arrays.asList(data.split(" ")));
        return deserializeHelper(nodes);
    }
    // Helper function to deserialize the tree
    private TreeNode deserializeHelper(Queue<string> nodes) {
        String val = nodes.poll();
        if (val.equals("null")) {
            return null;
        }
        TreeNode node = new TreeNode(Integer.parseInt(val));
        node.left = deserializeHelper(nodes);
        node.right = deserializeHelper(nodes);
        return node;
    }
    public static void main(String[] args) {
        // Example usage:
        // Constructing a binary tree:
        //      1
        //     / \
        //    3   2
        //   / \
        //  4   5
        TreeNode root = new TreeNode(1);          // Root node with value 1
        root.left = new TreeNode(3);              // Left child of root with value 3
        root.right = new TreeNode(2);             // Right child of root with value 2
        root.left.left = new TreeNode(4);         // Left child of node with value 3, value 4
        root.left.right = new TreeNode(5);        // Right child of node with value 3, value 5
        SerializeDeserializeBinaryTree solution = new SerializeDeserializeBinaryTree();  // Create an instance of SerializeDeserializeBinaryTree
        // Serialize the binary tree
        String serializedString = solution.serialize(root);
        System.out.println("Serialized tree: " + serializedString);
        // Deserialize the serialized string
        TreeNode deserializedRoot = solution.deserialize(serializedString);
        // Print the inorder traversal of the deserialized tree to verify
        System.out.print("Inorder traversal of deserialized tree: ");
        solution.printInorder(deserializedRoot);
        System.out.println();
    }
    // Method to print the tree using inorder traversal (for verification)
    public void printInorder(TreeNode root) {
        if (root != null) {
            printInorder(root.left);
            System.out.print(root.val + " ");
            printInorder(root.right);
        }
    }
}
</string></string>

Output:

Serialized tree: 1 3 4 null null 5 null null 2 null null 
Inorder traversal of deserialized tree: 4 3 5 1 2

Time Complexity: O(n) where n is the number of nodes in the binary tree.

Auxiliary Space: O(n) where n is the number of nodes in the binary tree.

Application of Binary Trees

Search Algorithms: Binary search trees (BSTs) enable efficient search operations. The search for a specific element can be performed in O(log n) time complexity, where n is the number of nodes, making it faster than linear search in unsorted data.
Sorting Algorithms: Binary trees are the basis for efficient sorting algorithms like binary search tree sort and heap sort. These algorithms benefit from the tree's structure to organize data and perform sorting operations efficiently.
Database Systems: Binary trees are used in database systems to store and manage data. Each node represents a record, allowing for efficient search operations and handling large datasets. B-trees and their variants are commonly used for indexing in databases.
File Systems: Binary trees can be used to implement file systems, where each node represents a directory or file. This structure allows for efficient navigation, organization, and searching within the file system.
Compression Algorithms: Huffman coding, a popular compression algorithm, uses binary trees to assign variable-length codes to characters based on their frequency in the input data. This leads to efficient data compression by reducing the overall size.
Decision Trees: In machine learning, decision trees are used for classification and regression analysis. Each node represents a decision based on an attribute, and the structure of the tree helps in making predictions by traversing from the root to the leaf nodes.
Game AI: Binary trees are employed in game AI to represent possible moves in a game. The AI algorithm searches the tree to evaluate and choose the best possible move, improving the decision-making process in games like chess or tic-tac-toe.

Advantages of Binary Tree

Efficient Searching: Binary trees enable efficient searching operations since each node has at most two children, allowing the use of binary search algorithms. This facilitates search operations with a time complexity of O(log n).
Ordered Traversal: The structure of binary trees supports various traversal methods, such as in-order, pre-order, and post-order traversals. This allows for operations on nodes in a specified sequence, such as printing nodes in sorted order.
Memory Efficiency: Binary trees are relatively memory-efficient compared to other tree structures because each node requires only two pointers. This makes them suitable for storing large amounts of data in memory while maintaining efficient search operations.
Fast Insertion and Deletion: Binary trees support insertion and deletion operations with a time complexity of O(log n). This makes them ideal for dynamic data structures used in applications like database systems.
Ease of Implementation: Binary trees are straightforward to implement and understand, making them a popular choice for a variety of applications.
Effective Sorting: Binary trees are useful for implementing efficient sorting algorithms, such as heap sort and binary search tree sort.

Disadvantages of Binary Tree

Limited Structure: Binary trees are constrained to two child nodes per node, which may not be suitable for applications that require nodes with more than two children. In such cases, different tree structures might be more appropriate.
Unbalanced Trees: Unbalanced binary trees, where one subtree is significantly larger than the other, can lead to inefficient search operations. This can happen if the tree is not properly balanced or if data is inserted in a non-random order.
Space Inefficiency: Binary trees can be space-inefficient compared to other data structures due to the two child pointers required for each node, leading to significant memory overhead for large trees.
Slow Performance in Worst-Case Scenarios: In the worst-case scenario, a binary tree can become degenerate, resembling a linked list where each node has only one child. In such cases, search operations degrade to O(n) time complexity.
Complex Balancing Algorithms: Maintaining balanced binary trees often requires complex algorithms, such as those used in AVL trees and red-black trees. These balancing mechanisms can be challenging to implement and add additional overhead, making them less suitable for some applications.

Next TopicHow to Create Zip File in Java

← prev next →