feat: add solutions to lcof2 problems: No.052, 055

- No.剑指 Offer II 052. 展平二叉搜索树
- No.剑指 Offer II 055. 二叉搜索树迭代器

Author: YangFong

lcof2/剑指 Offer II 052. 展平二叉搜索树/README.md

@@ -199,6 +199,124 @@ public:
 };
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function increasingBST(root: TreeNode | null): TreeNode | null {
+    const dummy = new TreeNode();
+    let cur = dummy;
+    const dfs = (root: TreeNode | null) => {
+        if (root == null) {
+            return;
+        }
+        dfs(root.left);
+        cur.right = new TreeNode(root.val);
+        cur = cur.right;
+        dfs(root.right);
+    };
+    dfs(root);
+    return dummy.right;
+}
+```
+
+### **Rust**
+
+```rust
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, vals: &mut Vec<i32>) {
+        if root.is_none() {
+            return;
+        }
+        let node = root.as_ref().unwrap().borrow();
+        Self::dfs(&node.left, vals);
+        vals.push(node.val);
+        Self::dfs(&node.right, vals);
+    }
+
+    pub fn increasing_bst(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        let mut vals = Vec::new();
+        Self::dfs(&root, &mut vals);
+        let mut dummy = Rc::new(RefCell::new(TreeNode::new(0)));
+        for &val in vals.iter().rev() {
+            let mut dummy = dummy.as_ref().borrow_mut();
+            dummy.right = Some(Rc::new(RefCell::new(TreeNode {
+                val,
+                left: None,
+                right: dummy.right.take(),
+            })));
+        }
+        let ans = dummy.as_ref().borrow_mut().right.take();
+        ans
+    }
+}
+```
+
+### **C**
+
+```c
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+
+struct TreeNode *dfs(struct TreeNode *root, struct TreeNode *cur) {
+    if (!root) {
+        return cur;
+    }
+    cur = dfs(root->left, cur);
+    cur->right = malloc(sizeof(struct TreeNode));
+    cur->right->val = root->val;
+    cur->right->left = NULL;
+    cur->right->right = NULL;
+    cur = cur->right;
+    return dfs(root->right, cur);
+}
+
+struct TreeNode *increasingBST(struct TreeNode *root) {
+    struct TreeNode *dummy = malloc(sizeof(struct TreeNode));
+    dfs(root, dummy);
+    return dummy->right;
+}
+```
+
 ### **...**
 
 ```

lcof2/剑指 Offer II 052. 展平二叉搜索树/Solution.c

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+
+struct TreeNode *dfs(struct TreeNode *root, struct TreeNode *cur) {
+    if (!root) {
+        return cur;
+    }
+    cur = dfs(root->left, cur);
+    cur->right = malloc(sizeof(struct TreeNode));
+    cur->right->val = root->val;
+    cur->right->left = NULL;
+    cur->right->right = NULL;
+    cur = cur->right;
+    return dfs(root->right, cur);
+}
+
+struct TreeNode *increasingBST(struct TreeNode *root) {
+    struct TreeNode *dummy = malloc(sizeof(struct TreeNode));
+    dfs(root, dummy);
+    return dummy->right;
+}

lcof2/剑指 Offer II 052. 展平二叉搜索树/Solution.rs

@@ -0,0 +1,47 @@
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, vals: &mut Vec<i32>) {
+        if root.is_none() {
+            return;
+        }
+        let node = root.as_ref().unwrap().borrow();
+        Self::dfs(&node.left, vals);
+        vals.push(node.val);
+        Self::dfs(&node.right, vals);
+    }
+
+    pub fn increasing_bst(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        let mut vals = Vec::new();
+        Self::dfs(&root, &mut vals);
+        let mut dummy = Rc::new(RefCell::new(TreeNode::new(0)));
+        for &val in vals.iter().rev() {
+            let mut dummy = dummy.as_ref().borrow_mut();
+            dummy.right = Some(Rc::new(RefCell::new(TreeNode {
+                val,
+                left: None,
+                right: dummy.right.take(),
+            })));
+        }
+        let ans = dummy.as_ref().borrow_mut().right.take();
+        ans
+    }
+}

lcof2/剑指 Offer II 052. 展平二叉搜索树/Solution.ts

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function increasingBST(root: TreeNode | null): TreeNode | null {
+    const dummy = new TreeNode();
+    let cur = dummy;
+    const dfs = (root: TreeNode | null) => {
+        if (root == null) {
+            return;
+        }
+        dfs(root.left);
+        cur.right = new TreeNode(root.val);
+        cur = cur.right;
+        dfs(root.right);
+    };
+    dfs(root);
+    return dummy.right;
+}

lcof2/剑指 Offer II 055. 二叉搜索树迭代器/README.md

@@ -442,6 +442,122 @@ BSTIterator.prototype.hasNext = function () {
  */
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+class BSTIterator {
+    private stack: number[];
+
+    constructor(root: TreeNode | null) {
+        this.stack = [];
+        const dfs = ({ val, left, right }: TreeNode) => {
+            right && dfs(right);
+            this.stack.push(val);
+            left && dfs(left);
+        };
+        dfs(root);
+    }
+
+    next(): number {
+        return this.stack.pop();
+    }
+
+    hasNext(): boolean {
+        return this.stack.length !== 0;
+    }
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * var obj = new BSTIterator(root)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */
+```
+
+### **Rust**
+
+```rust
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell; 
+struct BSTIterator {
+    stack: Vec<i32>
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl BSTIterator {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, stack: &mut Vec<i32>) {
+        let node = root.as_ref().unwrap().borrow();
+        if node.right.is_some() {
+            Self::dfs(&node.right, stack);
+        }
+        stack.push(node.val);
+        if node.left.is_some() {
+            Self::dfs(&node.left, stack);
+        }
+    }
+
+    fn new(root: Option<Rc<RefCell<TreeNode>>>) -> Self {
+        let mut stack = Vec::new();
+        Self::dfs(&root, &mut stack);
+        Self {
+            stack
+        }
+    }
+
+    fn next(&mut self) -> i32 {
+        self.stack.pop().unwrap()
+    }
+
+    fn has_next(&self) -> bool {
+        !self.stack.is_empty()
+    }
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * let obj = BSTIterator::new(root);
+ * let ret_1: i32 = obj.next();
+ * let ret_2: bool = obj.has_next();
+ */
+```
+
 ### **...**
 
 ```