diff --git a/Data-Structures/Trees/BinaryTree.java b/Data-Structures/Trees/BinaryTree.java
index c7b9e73..8b8eaa3 100644
--- a/Data-Structures/Trees/BinaryTree.java
+++ b/Data-Structures/Trees/BinaryTree.java
@@ -1,37 +1,39 @@
-class Node {
+// Manual tree traversal demo:
+// This example builds a tree by wiring nodes manually and prints DFS traversals.
+class TraversalNode {
     int data;
-    Node left;
-    Node right;
+    TraversalNode left;
+    TraversalNode right;
 
-    public Node(int key) {
+    TraversalNode(int key) {
         data = key;
         left = right = null;
     }
 }
 
-class BinaryTreeStructure {
-    Node root = null;
+class ManualTraversalTree {
+    TraversalNode root = null;
 
-    void inorder_traversal(Node node) {
+    void inorderTraversal(TraversalNode node) {
         if (node != null) {
-            inorder_traversal(node.left);
+            inorderTraversal(node.left);
             System.out.print(node.data + " ");
-            inorder_traversal(node.right);
+            inorderTraversal(node.right);
         }
     }
 
-    void pre_order_traversal(Node node) {
+    void preOrderTraversal(TraversalNode node) {
         if (node != null) {
             System.out.print(node.data + " ");
-            pre_order_traversal(node.left);
-            pre_order_traversal(node.right);
+            preOrderTraversal(node.left);
+            preOrderTraversal(node.right);
         }
     }
 
-    void post_order_traversal(Node node) {
+    void postOrderTraversal(TraversalNode node) {
         if (node != null) {
-            post_order_traversal(node.left);
-            post_order_traversal(node.right);
+            postOrderTraversal(node.left);
+            postOrderTraversal(node.right);
             System.out.print(node.data + " ");
         }
     }
@@ -39,21 +41,23 @@ void post_order_traversal(Node node) {
 
 public class BinaryTree {
     public static void main(String[] args) {
-        BinaryTreeStructure tree = new BinaryTreeStructure();
-        tree.root = new Node(27);
-        tree.root.left = new Node(12);
-        tree.root.right = new Node(3);
-        tree.root.left.left = new Node(44);
-        tree.root.left.right = new Node(17);
-        tree.root.right.left = new Node(56);
+        ManualTraversalTree tree = new ManualTraversalTree();
+
+        // Manually building a sample tree for traversal demonstration.
+        tree.root = new TraversalNode(27);
+        tree.root.left = new TraversalNode(12);
+        tree.root.right = new TraversalNode(3);
+        tree.root.left.left = new TraversalNode(44);
+        tree.root.left.right = new TraversalNode(17);
+        tree.root.right.left = new TraversalNode(56);
 
         System.out.println("Inorder traversal:");
-        tree.inorder_traversal(tree.root);
+        tree.inorderTraversal(tree.root);
 
         System.out.println("\nPreorder traversal:");
-        tree.pre_order_traversal(tree.root);
+        tree.preOrderTraversal(tree.root);
 
         System.out.println("\nPostorder traversal:");
-        tree.post_order_traversal(tree.root);
+        tree.postOrderTraversal(tree.root);
     }
 }
diff --git a/Data-Structures/Trees/BinaryTreeImplementation.java b/Data-Structures/Trees/BinaryTreeImplementation.java
new file mode 100644
index 0000000..8702105
--- /dev/null
+++ b/Data-Structures/Trees/BinaryTreeImplementation.java
@@ -0,0 +1,125 @@
+// Full binary search tree implementation with insert, search, and delete.
+// Delete handles all cases explicitly:
+// 1) leaf node, 2) node with one child, 3) node with two children.
+public class BinaryTreeImplementation {
+    static class Node {
+        int data;
+        Node left;
+        Node right;
+
+        Node(int data) {
+            this.data = data;
+        }
+    }
+
+    private Node root;
+
+    public void insert(int value) {
+        root = insertRecursive(root, value);
+    }
+
+    private Node insertRecursive(Node node, int value) {
+        if (node == null) {
+            return new Node(value);
+        }
+        if (value < node.data) {
+            node.left = insertRecursive(node.left, value);
+        } else if (value > node.data) {
+            node.right = insertRecursive(node.right, value);
+        }
+        // Duplicate values are ignored to keep keys unique.
+        return node;
+    }
+
+    public boolean search(int value) {
+        Node current = root;
+        while (current != null) {
+            if (value == current.data) {
+                return true;
+            }
+            current = (value < current.data) ? current.left : current.right;
+        }
+        return false;
+    }
+
+    public void delete(int value) {
+        root = deleteRecursive(root, value);
+    }
+
+    private Node deleteRecursive(Node node, int value) {
+        if (node == null) {
+            return null;
+        }
+
+        if (value < node.data) {
+            node.left = deleteRecursive(node.left, value);
+        } else if (value > node.data) {
+            node.right = deleteRecursive(node.right, value);
+        } else {
+            // Case 1: leaf node.
+            if (node.left == null && node.right == null) {
+                return null;
+            }
+
+            // Case 2: one child.
+            if (node.left == null) {
+                return node.right;
+            }
+            if (node.right == null) {
+                return node.left;
+            }
+
+            // Case 3: two children.
+            // Replace with inorder successor (smallest in right subtree), then delete successor.
+            Node successor = findMinNode(node.right);
+            node.data = successor.data;
+            node.right = deleteRecursive(node.right, successor.data);
+        }
+
+        return node;
+    }
+
+    private Node findMinNode(Node node) {
+        Node current = node;
+        while (current.left != null) {
+            current = current.left;
+        }
+        return current;
+    }
+
+    public void inorderTraversal() {
+        inorderRecursive(root);
+        System.out.println();
+    }
+
+    private void inorderRecursive(Node node) {
+        if (node == null) {
+            return;
+        }
+        inorderRecursive(node.left);
+        System.out.print(node.data + " ");
+        inorderRecursive(node.right);
+    }
+
+    public static void main(String[] args) {
+        BinaryTreeImplementation tree = new BinaryTreeImplementation();
+
+        int[] values = {50, 30, 70, 20, 40, 60, 80, 65};
+        for (int value : values) {
+            tree.insert(value);
+        }
+
+        System.out.print("Initial inorder: ");
+        tree.inorderTraversal();
+
+        System.out.println("Search 40: " + tree.search(40));
+        System.out.println("Search 99: " + tree.search(99));
+
+        tree.delete(20); // leaf
+        tree.delete(60); // one child
+        tree.delete(70); // two children
+
+        System.out.print("Inorder after deletes: ");
+        tree.inorderTraversal();
+    }
+}
diff --git a/README.md b/README.md
index 342cc0f..fecd06d 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,8 @@ The repository is organized into folders based on topic for better navigation an
   - Linear Queue.
   - Circular Queue. 
 - Trees : 
-  - Binary Tree.
+  - Binary Tree (`BinaryTree.java`) manual traversal demo with a manually wired tree.
+  - Binary Tree full implementation (`BinaryTreeImplementation.java`) with insert/search/delete (leaf, one child, two children).
   - Binary Search Tree.
   - AVL Tree.
 - Graphs :