first

Author: joker53-1

src/problem/mod.rs

@@ -11,3 +11,10 @@ mod p0094_binary_tree_inorder_traversal;
 mod p0095_unique_binary_search_trees_ii;
 mod p0096_unique_binary_search_trees;
 mod p0098_validate_binary_search_tree;
+mod p0099_recover_binary_search_tree;
+mod p0100_same_tree;
+mod p0101_symmetric_tree;
+mod p0102_binary_tree_level_order_traversal;
+mod p0103_binary_tree_zigzag_level_order_traversal;
+mod p0104_maximum_depth_of_binary_tree;
+mod p0105_construct_binary_tree_from_preorder_and_inorder_traversal;

src/problem/p0099_recover_binary_search_tree.rs

@@ -0,0 +1,99 @@
+/**
+ * [99] Recover Binary Search Tree
+ *
+ * You are given the root of a binary search tree (BST), where the values of exactly two nodes of the tree were swapped by mistake. Recover the tree without changing its structure.
+ *  
+ * <strong class="example">Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/10/28/recover1.jpg" style="width: 422px; height: 302px;" />
+ * Input: root = [1,3,null,null,2]
+ * Output: [3,1,null,null,2]
+ * Explanation: 3 cannot be a left child of 1 because 3 > 1. Swapping 1 and 3 makes the BST valid.
+ * 
+ * <strong class="example">Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/10/28/recover2.jpg" style="width: 581px; height: 302px;" />
+ * Input: root = [3,1,4,null,null,2]
+ * Output: [2,1,4,null,null,3]
+ * Explanation: 2 cannot be in the right subtree of 3 because 2 < 3. Swapping 2 and 3 makes the BST valid.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [2, 1000].
+ * 	-2^31 <= Node.val <= 2^31 - 1
+ * 
+ *  
+ * Follow up: A solution using O(n) space is pretty straight-forward. Could you devise a constant O(1) space solution?
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/recover-binary-search-tree/
+// discuss: https://leetcode.com/problems/recover-binary-search-tree/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// 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 {
+    pub fn recover_tree(root: &mut Option<Rc<RefCell<TreeNode>>>) {
+        let mut res = vec![];
+        Self::dfs(root, &mut res);
+        let (mut x, mut y) = (None, None);
+        for i in 0..res.len()-1 {
+            if res[i+1] < res[i] { 
+                y = Some(res[i+1]);
+                if x == None { 
+                    x = Some(res[i]);
+                }
+            }
+        }
+        Self::recover_tree2(root, x.unwrap(), y.unwrap());
+    }
+    
+    fn dfs(node: &Option<Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+        if let Some(node) = node {
+            Self::dfs(&node.borrow().left, res);
+            res.push(node.borrow().val);
+            Self::dfs(&node.borrow().right, res);
+        }
+    }
+    
+    fn recover_tree2(root: &mut Option<Rc<RefCell<TreeNode>>>, x: i32, y: i32) {
+        if let Some(node) = root { 
+            Self::recover_tree2(&mut node.borrow_mut().left, x, y);
+            if node.borrow().val == x || node.borrow().val == y { 
+                node.borrow_mut().val = if node.borrow().val == x { y } else { x };
+            }
+            Self::recover_tree2(&mut node.borrow_mut().right, x, y);
+        }
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_99() {
+    }
+}

src/problem/p0100_same_tree.rs

@@ -0,0 +1,74 @@
+/**
+ * [100] Same Tree
+ *
+ * Given the roots of two binary trees p and q, write a function to check if they are the same or not.
+ * Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
+ *  
+ * <strong class="example">Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg" style="width: 622px; height: 182px;" />
+ * Input: p = [1,2,3], q = [1,2,3]
+ * Output: true
+ * 
+ * <strong class="example">Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg" style="width: 382px; height: 182px;" />
+ * Input: p = [1,2], q = [1,null,2]
+ * Output: false
+ * 
+ * <strong class="example">Example 3:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg" style="width: 622px; height: 182px;" />
+ * Input: p = [1,2,1], q = [1,1,2]
+ * Output: false
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in both trees is in the range [0, 100].
+ * 	-10^4 <= Node.val <= 10^4
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/same-tree/
+// discuss: https://leetcode.com/problems/same-tree/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// 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 {
+    pub fn is_same_tree(p: Option<Rc<RefCell<TreeNode>>>, q: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if p.is_none() && q.is_none() { return true; }
+        if (p.is_none() && q.is_some()) || (p.is_some() && q.is_none()) { return false;  }
+        Self::is_same_tree(p.as_ref().unwrap().borrow().left.clone(), q.as_ref().unwrap().borrow().left.clone()) && Self::is_same_tree(p.as_ref().unwrap().borrow().right.clone(), q.as_ref().unwrap().borrow().right.clone()) && p.unwrap().borrow().val == q.unwrap().borrow().val 
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_100() {
+    }
+}

src/problem/p0101_symmetric_tree.rs

@@ -0,0 +1,75 @@
+/**
+ * [101] Symmetric Tree
+ *
+ * Given the root of a binary tree, check whether it is a mirror of itself (i.e., symmetric around its center).
+ *  
+ * <strong class="example">Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/symtree1.jpg" style="width: 354px; height: 291px;" />
+ * Input: root = [1,2,2,3,4,4,3]
+ * Output: true
+ * 
+ * <strong class="example">Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/symtree2.jpg" style="width: 308px; height: 258px;" />
+ * Input: root = [1,2,2,null,3,null,3]
+ * Output: false
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [1, 1000].
+ * 	-100 <= Node.val <= 100
+ * 
+ *  
+ * Follow up: Could you solve it both recursively and iteratively?
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/symmetric-tree/
+// discuss: https://leetcode.com/problems/symmetric-tree/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// 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 {
+    pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if root.is_none() { return true; }
+        Self::is_same_tree(root.as_ref().unwrap().borrow().left.clone(), root.as_ref().unwrap().borrow().right.clone())
+    }
+    
+    fn is_same_tree(p: Option<Rc<RefCell<TreeNode>>>, q: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if p.is_none() && q.is_none() { return true; }
+        if (p.is_none() && q.is_some()) || (p.is_some() && q.is_none()) { return false;  }
+        Self::is_same_tree(p.as_ref().unwrap().borrow().left.clone(), q.as_ref().unwrap().borrow().right.clone()) && Self::is_same_tree(p.as_ref().unwrap().borrow().right.clone(), q.as_ref().unwrap().borrow().left.clone()) && p.unwrap().borrow().val == q.unwrap().borrow().val
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_101() {
+    }
+}

src/problem/p0102_binary_tree_level_order_traversal.rs

@@ -0,0 +1,128 @@
+/**
+ * [102] Binary Tree Level Order Traversal
+ *
+ * Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).
+ *  
+ * <strong class="example">Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
+ * Input: root = [3,9,20,null,null,15,7]
+ * Output: [[3],[9,20],[15,7]]
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: root = [1]
+ * Output: [[1]]
+ * 
+ * <strong class="example">Example 3:
+ * 
+ * Input: root = []
+ * Output: []
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	The number of nodes in the tree is in the range [0, 2000].
+ * 	-1000 <= Node.val <= 1000
+ * 
+ */
+pub struct Solution {}
+use crate::util::tree::{TreeNode, to_tree};
+
+// problem: https://leetcode.com/problems/binary-tree-level-order-traversal/
+// discuss: https://leetcode.com/problems/binary-tree-level-order-traversal/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+// 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;
+use std::collections::VecDeque;
+
+impl Solution {
+    pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+        // if root.is_none() { return vec![]; }
+        // let mut q = VecDeque::new();
+        // q.push_back(root);
+        // let mut res = Vec::new();
+        // while !q.is_empty() {
+        //     let len = q.len();
+        //     let mut level = Vec::new();
+        //     for _ in 0..len {
+        //         if let Some(node) = q.pop_front() {
+        //             if let Some(c) = node {
+        //                 q.push_back(c.borrow().left.clone());
+        //                 q.push_back(c.borrow().right.clone());
+        //                 level.push(c.borrow().val);
+        //             }
+        //         }
+        //     }
+        //     if !level.is_empty() {
+        //         res.push(level);
+        //     }
+        // }
+        // res
+
+        let root = match root {
+            Some(node) => node,
+            None => return Vec::new(),
+        };
+
+        let mut queue = VecDeque::new();
+        queue.push_back(root);
+        let mut result = Vec::new();
+
+        while !queue.is_empty() {
+            let level_size = queue.len();
+            let mut current_level = Vec::with_capacity(level_size);
+
+            for _ in 0..level_size {
+                let node = queue.pop_front().unwrap();
+
+                // 只借用一次
+                {
+                    let node_ref = node.borrow();
+                    current_level.push(node_ref.val);
+
+                    if let Some(left) = node_ref.left.as_ref() {
+                        queue.push_back(Rc::clone(left));
+                    }
+                    if let Some(right) = node_ref.right.as_ref() {
+                        queue.push_back(Rc::clone(right));
+                    }
+                } // 借用在这里结束
+            }
+
+            result.push(current_level);
+        }
+
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_102() {
+    }
+}