feat: add java solution to lc problem: No.1028 (doocs#4096)

Author: PATILYASH007

solution/1000-1099/1028.Recover a Tree From Preorder Traversal/README.md

@@ -74,6 +74,63 @@ tags:
 
 <!-- tabs:start -->
 
+#### Java
+
+```java
+/**
+ * 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;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode recoverFromPreorder(String traversal) {
+        Stack<TreeNode> stack = new Stack<>();
+        int i = 0;
+
+        while (i < traversal.length()) {
+            int depth = 0;
+            while (i < traversal.length() && traversal.charAt(i) == '-') {
+                depth++;
+                i++;
+            }
+
+            int num = 0;
+            while (i < traversal.length() && Character.isDigit(traversal.charAt(i))) {
+                num = num * 10 + (traversal.charAt(i) - '0');
+                i++;
+            }
+
+            // Create the new node
+            TreeNode newNode = new TreeNode(num);
+
+            while (stack.size() > depth) {
+                stack.pop();
+            }
+            if (!stack.isEmpty()) {
+                if (stack.peek().left == null) {
+                    stack.peek().left = newNode;
+                } else {
+                    stack.peek().right = newNode;
+                }
+            }
+
+            stack.push(newNode);
+        }
+        return stack.isEmpty() ? null : stack.get(0);
+    }
+}
+```
+
 #### C++
 
 ```cpp

solution/1000-1099/1028.Recover a Tree From Preorder Traversal/README_EN.md

@@ -69,6 +69,63 @@ tags:
 
 <!-- tabs:start -->
 
+#### Java
+
+```java
+/**
+ * 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;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode recoverFromPreorder(String traversal) {
+        Stack<TreeNode> stack = new Stack<>();
+        int i = 0;
+
+        while (i < traversal.length()) {
+            int depth = 0;
+            while (i < traversal.length() && traversal.charAt(i) == '-') {
+                depth++;
+                i++;
+            }
+
+            int num = 0;
+            while (i < traversal.length() && Character.isDigit(traversal.charAt(i))) {
+                num = num * 10 + (traversal.charAt(i) - '0');
+                i++;
+            }
+
+            // Create the new node
+            TreeNode newNode = new TreeNode(num);
+
+            while (stack.size() > depth) {
+                stack.pop();
+            }
+            if (!stack.isEmpty()) {
+                if (stack.peek().left == null) {
+                    stack.peek().left = newNode;
+                } else {
+                    stack.peek().right = newNode;
+                }
+            }
+
+            stack.push(newNode);
+        }
+        return stack.isEmpty() ? null : stack.get(0);
+    }
+}
+```
+
 #### C++
 
 ```cpp

solution/1000-1099/1028.Recover a Tree From Preorder Traversal/Solution.java

@@ -0,0 +1,52 @@
+/**
+ * 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;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode recoverFromPreorder(String traversal) {
+        Stack<TreeNode> stack = new Stack<>();
+        int i = 0;
+
+        while (i < traversal.length()) {
+            int depth = 0;
+            while (i < traversal.length() && traversal.charAt(i) == '-') {
+                depth++;
+                i++;
+            }
+
+            int num = 0;
+            while (i < traversal.length() && Character.isDigit(traversal.charAt(i))) {
+                num = num * 10 + (traversal.charAt(i) - '0');
+                i++;
+            }
+
+            // Create the new node
+            TreeNode newNode = new TreeNode(num);
+
+            while (stack.size() > depth) {
+                stack.pop();
+            }
+            if (!stack.isEmpty()) {
+                if (stack.peek().left == null) {
+                    stack.peek().left = newNode;
+                } else {
+                    stack.peek().right = newNode;
+                }
+            }
+
+            stack.push(newNode);
+        }
+        return stack.isEmpty() ? null : stack.get(0);
+    }
+}