LeetCode 226. Invert Binary Tree Rust

Author: raul-sauco

README.md

@@ -151,7 +151,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [219. Contains Duplicate II][lc219]                                                           | 🟢 Easy    | [![python](res/py.png)][lc219py]                                                             |
 | [222. Count Complete Tree Nodes][lc222]                                                       | 🟠 Medium  | [![python](res/py.png)][lc222py]                                                             |
 | [223. Rectangle Area][lc223]                                                                  | 🟠 Medium  | [![python](res/py.png)][lc223py]                                                             |
-| [226. Invert Binary Tree][lc226]                                                              | 🟢 Easy    | [![python](res/py.png)][lc226py]                                                             |
+| [226. Invert Binary Tree][lc226]                                                              | 🟢 Easy    | [![python](res/py.png)][lc226py] [![rust](res/rs.png)][lc226rs]                              |
 | [227. Basic Calculator II][lc227]                                                             | 🟠 Medium  | [![python](res/py.png)][lc227py]                                                             |
 | [230. Kth Smallest Element in a BST][lc230]                                                   | 🟠 Medium  | [![python](res/py.png)][lc230py]                                                             |
 | [232. Implement Queue using Stacks][lc232]                                                    | 🟢 Easy    | [![python](res/py.png)][lc232py]                                                             |
@@ -700,6 +700,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc223py]: leetcode/rectangle-area.py
 [lc226]: https://leetcode.com/problems/invert-binary-tree/
 [lc226py]: leetcode/invert-binary-tree.py
+[lc226rs]: leetcode/invert-binary-tree.rs
 [lc227]: https://leetcode.com/problems/basic-calculator-ii/
 [lc227py]: leetcode/basic-calculator-ii.py
 [lc230]: https://leetcode.com/problems/kth-smallest-element-in-a-bst/

leetcode/invert-binary-tree.py

@@ -33,6 +33,27 @@ def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
         return root
 
 
+# Use depth-first search to visit all nodes in the tree, for each node,
+# swap the position of its children, recursively call the function on
+# the children.
+#
+# Time complexity: O(n) - We visit each node in the tree and, for each,
+# do O(1) work.
+# Space complexity: O(h) - The call stack can grow to the height of the
+# tree, which could be the same as n.
+#
+# Runtime 38 ms Beats 33.89%
+# Memory 13.8 MB Beats 94.48%
+class RecursiveInPlace:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root:
+            return None
+        root.left, root.right = self.invertTree(root.right), self.invertTree(
+            root.left
+        )
+        return root
+
+
 # Use depth-first search to visit all nodes in the tree, for each node,
 # swap the position of its children.
 #
@@ -42,7 +63,7 @@ def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
 # which could be the same as n.
 #
 # Runtime 31 ms Beats 92.4%
-# Memory 13.9 MB Beats 57.73%
+# Memory 13.8 MB Beats 94.98%
 class IterativeDFS:
     def invertTree(self, root):
         stack = [root]
@@ -59,6 +80,7 @@ def test():
     executors = [
         IterativeDFS,
         RecursiveDFS,
+        RecursiveInPlace,
     ]
     tests = [
         [[], []],

leetcode/invert-binary-tree.rs

@@ -0,0 +1,61 @@
+// 226. Invert Binary Tree
+// 🟢 Easy
+//
+// https://leetcode.com/problems/invert-binary-tree/
+//
+// Tags: Tree - Depth-First Search - Breadth-First Search - Binary Tree
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+struct Solution;
+impl Solution {
+    // Use depth-first search to visit all nodes in the tree, for each node,
+    // swap the position of its children.
+    //
+    // Time complexity: O(n) - We visit each node in the tree and, for each,
+    // do O(1) work.
+    // Space complexity: O(h) - The call stack can grow to the height of the
+    // tree, which could be the same as n.
+    //
+    // Runtime 1 ms Beats 66.37%
+    // Memory 2 MB Beats 65.49%
+    pub fn invert_tree(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        match root {
+            Some(node_ref) => {
+                let tmp = node_ref.borrow();
+                Some(Rc::new(RefCell::new(TreeNode {
+                    val: tmp.val,
+                    left: Self::invert_tree(tmp.right.clone()),
+                    right: Self::invert_tree(tmp.left.clone()),
+                })))
+            }
+            None => None,
+        }
+    }
+}
+
+// Tests.
+fn main() {
+    // assert_eq!(Solution::min_diff_in_bst(root), 1);
+    println!("All tests passed!")
+}
+
+// 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,
+        }
+    }
+}