removes TreeNode dependency

Author: anishLearnsToCode

src/BalancedBinaryTree.java

@@ -1,9 +1,4 @@
 public class BalancedBinaryTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public static boolean isBalanced(TreeNode root) {
         return height(root) != -1;

src/BinaryTreeLevelOrderTraversalII.java

@@ -5,11 +5,6 @@
 import java.util.Queue;
 
 public class BinaryTreeLevelOrderTraversalII {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     private static class Pair {
         TreeNode tree;

src/BinaryTreePaths.java

@@ -2,24 +2,10 @@
 import java.util.List;
 
 public class BinaryTreePaths {
-    public static void main(String[] args) {
-        String[] array = {"hello", "1", "2"};
-        List<CharSequence> list = new ArrayList<>();
-        list.add("1");
-        list.add("2");
-        list.add("3");
-        System.out.println(String.join("->", list));
-    }
-
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public static List<String> binaryTreePaths(TreeNode root) {
         List<String> result = new ArrayList<>();
-        binaryTreePaths(root, new ArrayList<CharSequence>(), result);
+        binaryTreePaths(root, new ArrayList<>(), result);
         return result;
     }
 

src/ConvertSortedArrayToBinarySearchTree.java

@@ -1,19 +1,4 @@
 public class ConvertSortedArrayToBinarySearchTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-
-        TreeNode(int val) {
-            this.val = val;
-        }
-
-        TreeNode(int val, TreeNode left, TreeNode right) {
-            this.val = val;
-            this.left = left;
-            this.right = right;
-        }
-    }
 
     public static TreeNode sortedArrayToBST(int[] array) {
         return sortedArrayToBST(array, 0, array.length);

src/FindModeInBinarySearchTree.java

@@ -3,19 +3,6 @@
 import java.util.List;
 
 public class FindModeInBinarySearchTree {
-    static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-        TreeNode() {}
-        TreeNode(int val) { this.val = val; }
-        TreeNode(int val, TreeNode left, TreeNode right) {
-            this.val = val;
-            this.left = left;
-            this.right = right;
-        }
-    }
-
     private static TreeNode previous;
     private static int count = 1;
     private static int mode = 0;

src/InvertBinaryTree.java

@@ -1,9 +1,4 @@
 public class InvertBinaryTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public static TreeNode invertTree(TreeNode root) {
         if (root == null) {

src/LowestCommonAncestorOfBinarySearchTree.java

@@ -2,11 +2,6 @@
 import java.util.List;
 
 public class LowestCommonAncestorOfBinarySearchTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
         List<TreeNode> pathToP = pathTo(root, p);

src/MaximumDepthOfBinaryTree.java

@@ -1,10 +1,4 @@
 public class MaximumDepthOfBinaryTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
-
     public int maxDepth(TreeNode root) {
         if (root == null) {
             return 0;

src/MinimumDepthOfBinaryTree.java

@@ -1,9 +1,4 @@
 public class MinimumDepthOfBinaryTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public static int minDepth(TreeNode root) {
         if (root == null) {

src/PathSum.java

@@ -1,9 +1,4 @@
 public class PathSum {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public static boolean hasPathSum(TreeNode root, int sum) {
         return root != null && hasPathSum(root, sum, root.val);

src/SameTree.java

@@ -1,9 +1,4 @@
 public class SameTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public boolean isSameTree(TreeNode p, TreeNode q) {
         if (p == null && q == null) {

src/SymmetricTree.java

@@ -1,9 +1,4 @@
 public class SymmetricTree {
-    private static class TreeNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-    }
 
     public boolean isSymmetric(TreeNode root) {
         return root == null || isSymmetric(root.left, root.right);

src/UniqueBinarySearchTreesII.java

@@ -2,47 +2,16 @@
 import java.util.List;
 
 public class UniqueBinarySearchTreesII {
-    private static class TreeNode implements TreePrinter.PrintableNode {
-        int val;
-        TreeNode left;
-        TreeNode right;
-
-        TreeNode(int val) {
-            this.val = val;
-        }
-
-        TreeNode(int val, TreeNode left, TreeNode right) {
-            this.val = val;
-            this.left = left;
-            this.right = right;
-        }
-
-        @Override
-        public TreePrinter.PrintableNode getLeft() {
-            return left;
-        }
-
-        @Override
-        public TreePrinter.PrintableNode getRight() {
-            return right;
-        }
-
-        @Override
-        public String getText() {
-            return val + "";
-        }
-    }
-
     public static List<TreeNode> generateTrees(int n) {
         List<TreeNode>[] result = new List[n + 1];
-        result[0] = new ArrayList<TreeNode>();
+        result[0] = new ArrayList<>();
         if (n == 0) {
             return result[0];
         }
 
         result[0].add(null);
         for (int len = 1; len <= n; len++) {
-            result[len] = new ArrayList<TreeNode>();
+            result[len] = new ArrayList<>();
             for (int j = 0; j < len; j++) {
                 for (TreeNode nodeL : result[j]) {
                     for (TreeNode nodeR : result[len - j - 1]) {