added binary traversals in java

Java/BInaryTree/BFS_DFS_Explanation.txt

@@ -0,0 +1,12 @@
+
+TraversalBFS.java and TraversalDFS.java implement two types of tree traversals: Breadth-First Search (BFS) and Depth-First Search (DFS) respectively.
+
+1. TraversalBFS.java:
+   - This class performs BFS traversal (also known as level-order traversal) on a binary tree.
+   - BFS explores nodes level by level, starting from the root, visiting all nodes at each depth before moving to the next level.
+   - The traversal uses a queue data structure to keep track of nodes to visit. Nodes are added to the queue starting with the root. Then for each node, the left and right children are enqueued before the next node is dequeued for processing.
+
+2. TraversalDFS.java:
+   - This class performs DFS traversal on a binary tree.
+   - DFS explores as far as possible along each branch before backtracking.
+   - The implementation here is a pre-order DFS traversal where the current node is processed first, then the left subtree, followed by the right subtree. It is done recursively without any external data structure like a queue.

Java/BInaryTree/TraversalBFS.java

@@ -0,0 +1,44 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+class TreeNode {
+    int val;
+    TreeNode left, right;
+
+    TreeNode(int item) {
+        val = item;
+        left = right = null;
+    }
+}
+
+public class TraversalBFS {
+    TreeNode root;
+
+    void bfsTraversal(TreeNode node) {
+        if (node == null) return;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(node);
+
+        while (!queue.isEmpty()) {
+            TreeNode currentNode = queue.poll();
+            System.out.print(currentNode.val + " ");
+
+            if (currentNode.left != null)
+                queue.add(currentNode.left);
+            if (currentNode.right != null)
+                queue.add(currentNode.right);
+        }
+    }
+
+    public static void main(String[] args) {
+        TraversalBFS tree = new TraversalBFS();
+        tree.root = new TreeNode(1);
+        tree.root.left = new TreeNode(2);
+        tree.root.right = new TreeNode(3);
+        tree.root.left.left = new TreeNode(4);
+        tree.root.left.right = new TreeNode(5);
+
+        tree.bfsTraversal(tree.root);
+    }
+}

Java/BInaryTree/TraversalDFS.java

@@ -0,0 +1,32 @@
+class TreeNode {
+    int val;
+    TreeNode left, right;
+
+    TreeNode(int item) {
+        val = item;
+        left = right = null;
+    }
+}
+
+public class TraversalDFS {
+    TreeNode root;
+
+    void dfsTraversal(TreeNode node) {
+        if (node == null) return;
+
+        System.out.print(node.val + " ");
+        dfsTraversal(node.left);
+        dfsTraversal(node.right);
+    }
+
+    public static void main(String[] args) {
+        TraversalDFS tree = new TraversalDFS();
+        tree.root = new TreeNode(1);
+        tree.root.left = new TreeNode(2);
+        tree.root.right = new TreeNode(3);
+        tree.root.left.left = new TreeNode(4);
+        tree.root.left.right = new TreeNode(5);
+
+        tree.dfsTraversal(tree.root);
+    }
+}