feat: update leetcode solutions: No.0173. Binary Search Tree Iterator

Author: yanglbme

README.md

@@ -116,6 +116,7 @@
 - [从前序与中序遍历序列构造二叉树](/solution/0100-0199/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README.md)
 - [从中序与后序遍历序列构造二叉树](/solution/0100-0199/0106.Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/README.md)
 - [二叉搜索树的后序遍历序列](/lcof/面试题33.%20二叉搜索树的后序遍历序列/README.md)
+- [二叉搜索树迭代器](/solution/0100-0199/0173.Binary%20Search%20Tree%20Iterator/README.md)
 - [二叉树的最近公共祖先](/solution/0200-0299/0235.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree/README.md)
 - [二叉搜索树的最近公共祖先](/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/README.md)
 - [将二叉搜索树转换为单链表](/lcci/17.12.BiNode/README.md)

README_EN.md

@@ -112,6 +112,7 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 - [Path Sum II](/solution/0100-0199/0113.Path%20Sum%20II/README_EN.md)
 - [Construct Binary Tree from Preorder and Inorder Traversal](/solution/0100-0199/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README_EN.md)
 - [Construct Binary Tree from Inorder and Postorder Traversal](/solution/0100-0199/0106.Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/README_EN.md)
+- [Binary Search Tree Iterator](/solution/0100-0199/0173.Binary%20Search%20Tree%20Iterator/README_EN.md)
 - [Lowest Common Ancestor of a Binary Tree](/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/README_EN.md)
 - [Lowest Common Ancestor of a Binary Search Tree](/solution/0200-0299/0235.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree/README_EN.md)
 - [BiNode](/lcci/17.12.BiNode/README_EN.md)

index.html

@@ -26,7 +26,6 @@
   <script>
     window.$docsify = {
       name: 'leetcode',
-      repo: 'doocs/leetcode',
       logo: '/images/doocs-leetcode.png',
       search: [
         '/', '/solution/', '/lcof/', '/lcci/', '/basic/'

solution/0100-0199/0173.Binary Search Tree Iterator/README.md

@@ -39,22 +39,107 @@ iterator.hasNext(); // 返回 false</pre>
 
 <!-- 这里可写通用的实现逻辑 -->
 
+初始化数据时，递归中序遍历，将二叉搜索树每个结点的值保存在列表 `vals` 中。用 `cur/next` 指针记录外部即将遍历的位置，初始化为 0。
+
+调用 `next()` 时，返回 `vals[cur]`，同时 `cur` 指针自增。调用 `hasNext()` 时，判断 `cur` 指针是否已经达到 `vals` 个数，若是，说明已经遍历结束，返回 false，否则返回 true。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class BSTIterator:
+
+    def __init__(self, root: TreeNode):
+        def inorder(root):
+            if root is None:
+                return
+            inorder(root.left)
+            self.vals.append(root.val)
+            inorder(root.right)
+
+        self.cur = 0
+        self.vals = []
+        inorder(root)
+
+    def next(self) -> int:
+        res = self.vals[self.cur]
+        self.cur += 1
+        return res
+
+    def hasNext(self) -> bool:
+        return self.cur < len(self.vals)
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()
 ```
 
 ### **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 BSTIterator {
+
+    private List<Integer> vals;
+    private int next;
+
+    public BSTIterator(TreeNode root) {
+        next = 0;
+        vals = new ArrayList<>();
+        inorder(root);
+    }
+
+    public int next() {
+        return vals.get(next++);
+    }
+
+    public boolean hasNext() {
+        return next < vals.size();
+    }
+
+    private void inorder(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        inorder(root.left);
+        vals.add(root.val);
+        inorder(root.right);
+    }
+}
+
+/**
+ * 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();
+ */
 ```
 
 ### **...**

solution/0100-0199/0173.Binary Search Tree Iterator/README_EN.md

@@ -58,13 +58,94 @@ iterator.hasNext(); // return false
 ### **Python3**
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class BSTIterator:
+
+    def __init__(self, root: TreeNode):
+        def inorder(root):
+            if root is None:
+                return
+            inorder(root.left)
+            self.vals.append(root.val)
+            inorder(root.right)
+
+        self.cur = 0
+        self.vals = []
+        inorder(root)
+
+    def next(self) -> int:
+        res = self.vals[self.cur]
+        self.cur += 1
+        return res
+
+    def hasNext(self) -> bool:
+        return self.cur < len(self.vals)
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()
 ```
 
 ### **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 BSTIterator {
+
+    private List<Integer> vals;
+    private int next;
+
+    public BSTIterator(TreeNode root) {
+        next = 0;
+        vals = new ArrayList<>();
+        inorder(root);
+    }
+
+    public int next() {
+        return vals.get(next++);
+    }
+
+    public boolean hasNext() {
+        return next < vals.size();
+    }
+
+    private void inorder(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        inorder(root.left);
+        vals.add(root.val);
+        inorder(root.right);
+    }
+}
+
+/**
+ * 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();
+ */
 ```
 
 ### **...**

solution/0100-0199/0173.Binary Search Tree Iterator/Solution.java

@@ -4,43 +4,41 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class BSTIterator {
 
-    Stack<TreeNode> vector = new Stack<>();
-    TreeNode current;
+    private List<Integer> vals;
+    private int next;
 
     public BSTIterator(TreeNode root) {
-        current = root;
-        // 一直放入左儿子（左）
-        while (current != null) {
-            vector.push(current);
-            current = current.left;
-        }
+        next = 0;
+        vals = new ArrayList<>();
+        inorder(root);
     }
-
-    /** @return whether we have a next smallest number */
+    
+    public int next() {
+        return vals.get(next++);
+    }
+    
     public boolean hasNext() {
-        return !vector.isEmpty() || current != null;
+        return next < vals.size();
     }
 
-    /** @return the next smallest number */
-    public int next() {
-        // 一直放入左儿子（左）
-        while (current != null) {
-            vector.push(current);
-            current = current.left;
-        }
-        int ans = 0;
-        // 访问当前元素（中），把右儿子入栈（右）
-        if (!vector.isEmpty()) {
-            current = vector.pop();
-            ans = current.val;
-            current = current.right;
+    private void inorder(TreeNode root) {
+        if (root == null) {
+            return;
         }
-        return ans;
+        inorder(root.left);
+        vals.add(root.val);
+        inorder(root.right);
     }
 }
 

solution/0100-0199/0173.Binary Search Tree Iterator/Solution.py

@@ -0,0 +1,33 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class BSTIterator:
+
+    def __init__(self, root: TreeNode):
+        def inorder(root):
+            if root is None:
+                return
+            inorder(root.left)
+            self.vals.append(root.val)
+            inorder(root.right)
+
+        self.cur = 0
+        self.vals = []
+        inorder(root)
+
+    def next(self) -> int:
+        res = self.vals[self.cur]
+        self.cur += 1
+        return res
+
+    def hasNext(self) -> bool:
+        return self.cur < len(self.vals)
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()