diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index 470e1919..0b2ec0f6 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -574,66 +574,48 @@ object Solution {
 rust:
 ```rust
 impl Solution {
-    pub fn min_depth(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
-        return Solution::bfs(root)
-    }
-
     // 递归
-    pub fn dfs(node: Option<Rc<RefCell<TreeNode>>>) -> i32{
-        if node.is_none(){
-            return 0;
-        }
-        let parent = node.unwrap();
-        let left_child = parent.borrow_mut().left.take();
-        let right_child = parent.borrow_mut().right.take();
-        if left_child.is_none() && right_child.is_none(){
-            return 1;
-        }
-        let mut min_depth = i32::MAX;
-        if left_child.is_some(){
-            let left_depth = Solution::dfs(left_child);
-            if left_depth <= min_depth{
-                min_depth = left_depth
+    pub fn min_depth(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        if let Some(node) = root {
+            match (node.borrow().left.clone(), node.borrow().right.clone()) {
+                (Some(n1), None) => 1 + Self::min_depth(Some(n1)),
+                (None, Some(n2)) => 1 + Self::min_depth(Some(n2)),
+                (Some(n1), Some(n2)) => {
+                    1 + std::cmp::min(Self::min_depth(Some(n1)), Self::min_depth(Some(n2)))
+                }
+                _ => 1,
             }
+        } else {
+            0
         }
-        if right_child.is_some(){
-            let right_depth = Solution::dfs(right_child);
-            if right_depth <= min_depth{
-                min_depth = right_depth
-            }
-        }
-        min_depth + 1
-
     }
 
     // 迭代
-    pub fn bfs(node: Option<Rc<RefCell<TreeNode>>>) -> i32{
-        let mut min_depth = 0;
-        if node.is_none(){
-            return min_depth
+    // 需要 use std::collections::VecDeque;
+    pub fn min_depth(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        let mut res = 0;
+        let mut queue = VecDeque::new();
+        if root.is_some() {
+            queue.push_back(root);
         }
-        let mut stack = vec![node.unwrap()];
-        while !stack.is_empty(){
-            min_depth += 1;
-            let num = stack.len();
-            for _i in 0..num{
-                let top = stack.remove(0);
-                let left_child = top.borrow_mut().left.take();
-                let right_child = top.borrow_mut().right.take();
-                if left_child.is_none() && right_child.is_none(){
-                    return min_depth;
+        while !queue.is_empty() {
+            res += 1;
+            for _ in 0..queue.len() {
+                let node = queue.pop_front().unwrap().unwrap();
+                if node.borrow().left.is_none() && node.borrow().right.is_none() {
+                    return res;
                 }
-                if left_child.is_some(){
-                    stack.push(left_child.unwrap());
+                if node.borrow().left.is_some() {
+                    queue.push_back(node.borrow().left.clone());
                 }
-                if right_child.is_some(){
-                    stack.push(right_child.unwrap());
+                if node.borrow().right.is_some() {
+                    queue.push_back(node.borrow().right.clone());
                 }
             }
         }
-        min_depth
+        res
     }
-
+}
 ```
 
 <p align="center">