feat: 🎸 leetcode 1768

Author: dirk122119

README.md

@@ -1 +1,4 @@
 # leetcode_practice
+
+- [] 141. Linked List Cycle 
+- [] 104. Maximum Depth of Binary Tree stack solution

leet code/100. Same Tree/solution

@@ -0,0 +1,110 @@
+// 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 Solution;
+
+impl Solution {
+    pub fn is_same_tree(
+        p: Option<Rc<RefCell<TreeNode>>>,
+        q: Option<Rc<RefCell<TreeNode>>>
+    ) -> bool {
+        match (p, q) {
+            (None, None) => true,
+            (None, Some(_)) | (Some(_), None) => false,
+            (Some(ref node1), Some(ref node2)) => {
+                if node1.borrow().val == node2.borrow().val {
+                    return Self::is_same_tree(node1.borrow().left.clone(), node2.borrow().left.clone())
+                        && Self::is_same_tree(node1.borrow().right.clone(), node2.borrow().right.clone());
+                } else {
+                    false
+                }
+            }
+        }
+    }
+}
+
+fn main() {
+    let node1_p = Rc::new(RefCell::new(TreeNode::new(2)));
+    let node2_p = Rc::new(RefCell::new(TreeNode::new(3)));
+    let root_p = Rc::new(RefCell::new(TreeNode {
+        val: 1,
+        left: Some(node1_p),
+        right: Some(node2_p),
+    }));
+
+    let node1_q = Rc::new(RefCell::new(TreeNode::new(2)));
+    let node2_q = Rc::new(RefCell::new(TreeNode::new(3)));
+    let root_q = Rc::new(RefCell::new(TreeNode {
+        val: 1,
+        left: Some(node1_q),
+        right: Some(node2_q),
+    }));
+
+    let result = Solution::is_same_tree(Some(root_p), Some(root_q));
+    println!("Are the trees same? {:?}", result); // 输出: true
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_same_tree() {
+        let node1_p = Rc::new(RefCell::new(TreeNode::new(2)));
+        let node2_p = Rc::new(RefCell::new(TreeNode::new(3)));
+        let root_p = Rc::new(RefCell::new(TreeNode {
+            val: 1,
+            left: Some(node1_p),
+            right: Some(node2_p),
+        }));
+
+        let node1_q = Rc::new(RefCell::new(TreeNode::new(2)));
+        let node2_q = Rc::new(RefCell::new(TreeNode::new(3)));
+        let root_q = Rc::new(RefCell::new(TreeNode {
+            val: 1,
+            left: Some(node1_q),
+            right: Some(node2_q),
+        }));
+
+        assert!(Solution::is_same_tree(Some(root_p), Some(root_q)));
+
+        let node1_p = Rc::new(RefCell::new(TreeNode::new(2)));
+        let root_p = Rc::new(RefCell::new(TreeNode {
+            val: 1,
+            left: Some(node1_p),
+            right: None,
+        }));
+
+        let node1_q = Rc::new(RefCell::new(TreeNode::new(2)));
+        let root_q = Rc::new(RefCell::new(TreeNode {
+            val: 1,
+            left: None,
+            right: Some(node1_q),
+        }));
+
+        assert!(!Solution::is_same_tree(Some(root_p), Some(root_q)));
+
+        let root_p: Option<Rc<RefCell<TreeNode>>> = None;
+        let root_q: Option<Rc<RefCell<TreeNode>>> = None;
+        assert!(Solution::is_same_tree(root_p, root_q));
+    }
+}

leet code/100. Same Tree/solution.rs

@@ -0,0 +1,92 @@
+use std::rc::Rc;
+use std::cell::RefCell;
+
+// Definition for a binary tree node.
+#[derive(PartialEq, Eq, Clone, Debug)]
+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,
+        }
+    }
+}
+
+struct Solution;
+
+impl Solution {
+    pub fn max_depth(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        match root {
+            Some(n) => {
+                let node = n.borrow();
+                let left = Self::max_depth(node.left.clone());
+                let right = Self::max_depth(node.right.clone());
+                if left > right {
+                    left + 1
+                } else {
+                    right + 1
+                }
+            }
+            None => 0,
+        }
+    }
+}
+
+fn main() {
+    let node15 = Rc::new(RefCell::new(TreeNode::new(15)));
+    let node7 = Rc::new(RefCell::new(TreeNode::new(7)));
+    let node20 = Rc::new(RefCell::new(TreeNode {
+        val: 20,
+        left: Some(node15),
+        right: Some(node7),
+    }));
+    let node9 = Rc::new(RefCell::new(TreeNode::new(9)));
+    let root = Rc::new(RefCell::new(TreeNode {
+        val: 3,
+        left: Some(node9),
+        right: Some(node20),
+    }));
+
+    let result = Solution::max_depth(Some(root));
+    println!("Max depth: {:?}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_max_depth() {
+        // 测试普通二叉树
+        let node15 = Rc::new(RefCell::new(TreeNode::new(15)));
+        let node7 = Rc::new(RefCell::new(TreeNode::new(7)));
+        let node20 = Rc::new(RefCell::new(TreeNode {
+            val: 20,
+            left: Some(node15),
+            right: Some(node7),
+        }));
+        let node9 = Rc::new(RefCell::new(TreeNode::new(9)));
+        let root = Rc::new(RefCell::new(TreeNode {
+            val: 3,
+            left: Some(node9),
+            right: Some(node20),
+        }));
+        assert_eq!(Solution::max_depth(Some(root)), 3);
+
+        // 测试单个节点
+        let root = Rc::new(RefCell::new(TreeNode::new(1)));
+        assert_eq!(Solution::max_depth(Some(root)), 1);
+
+        // 测试空树
+        let root: Option<Rc<RefCell<TreeNode>>> = None;
+        assert_eq!(Solution::max_depth(root), 0);
+    }
+}

leet code/100. Same Tree/solution_test

@@ -0,0 +1,17 @@
+
+![image](./image/img.png)
+
+### ex1
+
+> input: word1 = "abc", word2 = "pqr"
+
+> output: "apbqcr"
+
+### ex2
+
+> input: word1 = "ab", word2 = "pqrs"
+
+> output: "apbqrs"
+
+## 思路
+使用兩個指標分別紀錄要合併字元的位置，合併完後往右走一格，直到全部都合併完成。

leet code/104. Maximum Depth of Binary Tree/solution

@@ -0,0 +1,49 @@
+struct Solution;
+
+impl Solution {
+    pub fn merge_alternately(word1: String, word2: String) -> String {
+        // let mut rs = String::new(); runtime beats 68%
+        let mut rs = String::with_capacity(word1.len() + word2.len());//runtime beats 100%
+        let mut w1_ptr = 0;
+        let mut w2_ptr = 0;
+        loop{
+            if w1_ptr<word1.len() && w2_ptr<word2.len() {
+                rs.push_str(&word1[w1_ptr..w1_ptr+1]);
+                rs.push_str(&word2[w2_ptr..w2_ptr+1]);
+                w1_ptr +=1;
+                w2_ptr +=1;
+            } else if w1_ptr<word1.len() {
+                rs.push_str(&word1[w1_ptr..w1_ptr+1]);
+                w1_ptr +=1;
+            } else if w2_ptr<word2.len(){
+                rs.push_str(&word2[w2_ptr..w2_ptr+1]);
+                w2_ptr +=1;
+            } else{
+                break;
+            } 
+        }
+        rs
+    }
+}
+
+fn main() {
+    let word1 = String::from("abc");
+    let word2 = String::from("pqr");
+    let result = Solution::merge_alternately(word1, word2);
+    println!("Merge alternately: {:?}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_merge_alternately() {
+        assert_eq!(Solution::merge_alternately(String::from("abc"), String::from("pqr")), String::from("apbqcr"));
+        assert_eq!(Solution::merge_alternately(String::from("ab"), String::from("pq")), String::from("apbq"));
+        assert_eq!(Solution::merge_alternately(String::from("a"), String::from("b")), String::from("ab"));
+        assert_eq!(Solution::merge_alternately(String::from("ab"), String::from("c")), String::from("acb"));
+        assert_eq!(Solution::merge_alternately(String::from("a"), String::from("")), String::from("a"));
+        assert_eq!(Solution::merge_alternately(String::from(""), String::from("b")), String::from("b"));
+    }
+}

leet code/104. Maximum Depth of Binary Tree/solution.rs

@@ -0,0 +1,105 @@
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>,
+}
+
+impl ListNode {
+    #[inline]
+    fn new(val: i32) -> Self {
+        ListNode {
+            next: None,
+            val,
+        }
+    }
+}
+
+struct Solution;
+
+impl Solution {
+    pub fn reverse_list(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut re_list: Option<Box<ListNode>> = None;
+        while let Some(mut current) = head {
+            head = current.next;
+            current.next = re_list;
+            re_list = Some(current);
+        }
+        re_list
+    }
+}
+
+fn main() {
+    // 创建一个链表: 1 -> 2 -> 3 -> 4 -> 5
+    let list = Some(Box::new(ListNode {
+        val: 1,
+        next: Some(Box::new(ListNode {
+            val: 2,
+            next: Some(Box::new(ListNode {
+                val: 3,
+                next: Some(Box::new(ListNode {
+                    val: 4,
+                    next: Some(Box::new(ListNode {
+                        val: 5,
+                        next: None,
+                    })),
+                })),
+            })),
+        })),
+    }));
+
+    // 反转链表
+    let result = Solution::reverse_list(list);
+
+    // 打印反转后的链表
+    println!("{:?}", result); // 输出: Some(ListNode { val: 5, next: Some(ListNode { val: 4, next: Some(ListNode { val: 3, next: Some(ListNode { val: 2, next: Some(ListNode { val: 1, next: None }) }) }) }) })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_reverse_list() {
+        let list = Some(Box::new(ListNode {
+            val: 1,
+            next: Some(Box::new(ListNode {
+                val: 2,
+                next: Some(Box::new(ListNode {
+                    val: 3,
+                    next: Some(Box::new(ListNode {
+                        val: 4,
+                        next: Some(Box::new(ListNode {
+                            val: 5,
+                            next: None,
+                        })),
+                    })),
+                })),
+            })),
+        }));
+        let reversed = Some(Box::new(ListNode {
+            val: 5,
+            next: Some(Box::new(ListNode {
+                val: 4,
+                next: Some(Box::new(ListNode {
+                    val: 3,
+                    next: Some(Box::new(ListNode {
+                        val: 2,
+                        next: Some(Box::new(ListNode {
+                            val: 1,
+                            next: None,
+                        })),
+                    })),
+                })),
+            })),
+        }));
+        assert_eq!(Solution::reverse_list(list), reversed);
+
+        let list = None;
+        let reversed = None;
+        assert_eq!(Solution::reverse_list(list), reversed);
+
+        let list = Some(Box::new(ListNode::new(1)));
+        let reversed = Some(Box::new(ListNode::new(1)));
+        assert_eq!(Solution::reverse_list(list), reversed);
+    }
+}