feat: BinaryTreeToString.java Added with tests

Author: mjk22071998

src/main/java/com/thealgorithms/datastructures/trees/BinaryTreeToString.java

@@ -0,0 +1,55 @@
+package com.thealgorithms.datastructures.trees;
+
+/**
+ * Converts a Binary Tree to its string representation using preorder traversal.
+ * Rules:
+ * - Each node is wrapped in parentheses (val)
+ * - Include "()" when a right child exists without a left child
+ * - Skip empty parentheses otherwise
+ *
+ * Example:
+ *    Input:  1
+ *            / \
+ *           2   3
+ *            \
+ *             4
+ *    Output: "1(2()(4))(3)"
+ *
+ * Matches the logic from LeetCode 606, using a DFS traversal.
+ */
+public class BinaryTreeToString {
+
+    private StringBuilder sb;
+
+    public String tree2str(BinaryTree.Node root) {
+        if (root == null) {
+            return "";
+        }
+
+        sb = new StringBuilder();
+        dfs(root);
+        // remove the first and last parentheses
+        return sb.substring(1, sb.length() - 1);
+    }
+
+    private void dfs(BinaryTree.Node node) {
+        if (node == null) {
+            return;
+        }
+
+        sb.append("(").append(node.data);
+
+        if (node.left != null) {
+            dfs(node.left);
+        }
+
+        if (node.right != null && node.left == null) {
+            sb.append("()");
+            dfs(node.right);
+        } else if (node.right != null) {
+            dfs(node.right);
+        }
+
+        sb.append(")");
+    }
+}

src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeToStringTest.java

@@ -0,0 +1,57 @@
+package com.thealgorithms.datastructures.trees;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests for the BinaryTreeToString class.
+ */
+public class BinaryTreeToStringTest {
+
+    @Test
+    public void testTreeToStringBasic() {
+        BinaryTree tree = new BinaryTree();
+        tree.put(1);
+        tree.put(2);
+        tree.put(3);
+        tree.put(4);
+
+        BinaryTreeToString converter = new BinaryTreeToString();
+        String result = converter.tree2str(tree.getRoot());
+
+        // Output will depend on insertion logic of BinaryTree.put()
+        // which is BST-style, so result = "1()(2()(3()(4)))"
+        Assertions.assertEquals("1()(2()(3()(4)))", result);
+    }
+
+    @Test
+    public void testSingleNodeTree() {
+        BinaryTree tree = new BinaryTree();
+        tree.put(10);
+
+        BinaryTreeToString converter = new BinaryTreeToString();
+        String result = converter.tree2str(tree.getRoot());
+
+        Assertions.assertEquals("10", result);
+    }
+
+    @Test
+    public void testComplexTreeStructure() {
+        BinaryTree.Node root = new BinaryTree.Node(10);
+        root.left = new BinaryTree.Node(5);
+        root.right = new BinaryTree.Node(20);
+        root.right.left = new BinaryTree.Node(15);
+        root.right.right = new BinaryTree.Node(25);
+
+        BinaryTreeToString converter = new BinaryTreeToString();
+        String result = converter.tree2str(root);
+
+        Assertions.assertEquals("10(5)(20(15)(25))", result);
+    }
+
+    @Test
+    public void testNullTree() {
+        BinaryTreeToString converter = new BinaryTreeToString();
+        Assertions.assertEquals("", converter.tree2str(null));
+    }
+}