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);