Added TreeNode description.

Author: javadev

src/main/java/g0101_0200/s0101_symmetric_tree/Solution.java

@@ -6,6 +6,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public boolean isSymmetric(TreeNode root) {
         if (root == null) {

src/main/java/g0101_0200/s0102_binary_tree_level_order_traversal/Solution.java

@@ -9,6 +9,21 @@
 import java.util.List;
 import java.util.Queue;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public List<List<Integer>> levelOrder(TreeNode root) {
         List<List<Integer>> result = new ArrayList<>();

src/main/java/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/Solution.java

@@ -9,6 +9,21 @@
 import java.util.List;
 import java.util.Queue;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
         List<List<Integer>> result = new ArrayList<>();

src/main/java/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution.java

@@ -6,6 +6,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public int maxDepth(TreeNode root) {
         return findDepth(root, 0);

src/main/java/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.java

@@ -7,6 +7,21 @@
 import java.util.HashMap;
 import java.util.Map;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     private int j;
     private Map<Integer, Integer> map = new HashMap<>();

src/main/java/g0101_0200/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.java

@@ -5,6 +5,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public TreeNode buildTree(int[] inorder, int[] postorder) {
         int[] inIndex = new int[] {inorder.length - 1};

src/main/java/g0101_0200/s0107_binary_tree_level_order_traversal_ii/Solution.java

@@ -8,6 +8,21 @@
 import java.util.Collections;
 import java.util.List;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     private List<List<Integer>> order = new ArrayList<>();
 

src/main/java/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/Solution.java

@@ -5,6 +5,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public TreeNode sortedArrayToBST(int[] num) {
         /*1. Set up recursion*/

src/main/java/g0101_0200/s0109_convert_sorted_list_to_binary_search_tree/Solution.java

@@ -6,6 +6,31 @@
 import com_github_leetcode.ListNode;
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public TreeNode sortedListToBST(ListNode head) {
         // Empty list -> empty tree / sub-tree

src/main/java/g0101_0200/s0110_balanced_binary_tree/Solution.java

@@ -5,6 +5,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public boolean isBalanced(TreeNode root) {
         // Empty Tree is balanced

src/main/java/g0101_0200/s0111_minimum_depth_of_binary_tree/Solution.java

@@ -7,6 +7,21 @@
 import java.util.LinkedList;
 import java.util.Queue;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public int minDepth(TreeNode root) {
         if (root == null) {

src/main/java/g0101_0200/s0112_path_sum/Solution.java

@@ -5,6 +5,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public boolean hasPathSum(TreeNode root, int sum) {
         if (root == null) {

src/main/java/g0101_0200/s0113_path_sum_ii/Solution.java

@@ -7,6 +7,21 @@
 import java.util.ArrayList;
 import java.util.List;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
         List<List<Integer>> res = new ArrayList<>();

src/main/java/g0101_0200/s0114_flatten_binary_tree_to_linked_list/Solution.java

@@ -5,6 +5,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public void flatten(TreeNode root) {
         if (root != null) {

src/main/java/g0101_0200/s0173_binary_search_tree_iterator/BSTIterator.java

@@ -5,6 +5,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class BSTIterator {
     private TreeNode node;
 
@@ -37,3 +52,8 @@ public boolean hasNext() {
         return node != null;
     }
 }
+
+/**
+ * Your BSTIterator object will be instantiated and called as such: BSTIterator obj = new
+ * BSTIterator(root); int param_1 = obj.next(); boolean param_2 = obj.hasNext();
+ */

src/main/java/g0201_0300/s0226_invert_binary_tree/Solution.java

@@ -5,6 +5,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     public TreeNode invertTree(TreeNode root) {
         if (root == null) {

src/main/java/g0201_0300/s0230_kth_smallest_element_in_a_bst/Solution.java

@@ -6,6 +6,21 @@
 
 import com_github_leetcode.TreeNode;
 
+/*
+ * Definition for a binary tree node.
+ * public 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;
+ *     }
+ * }
+ */
 public class Solution {
     private int k;
     private int count = 0;