From 026dbc8f2bbec85457df8128bd5235c5c74e96d5 Mon Sep 17 00:00:00 2001
From: Tzcan <tzcan@foxmail.com>
Date: Tue, 2 Jun 2026 16:55:21 +0800
Subject: [PATCH] style/format-code: reduce code nesting

---
 src/data_structures/binary_search_tree.rs | 152 +++++++++++-----------
 1 file changed, 76 insertions(+), 76 deletions(-)

diff --git a/src/data_structures/binary_search_tree.rs b/src/data_structures/binary_search_tree.rs
index 5ff05f432ea..e3892223212 100644
--- a/src/data_structures/binary_search_tree.rs
+++ b/src/data_structures/binary_search_tree.rs
@@ -1,5 +1,4 @@
 use std::cmp::Ordering;
-use std::ops::Deref;
 
 /// This struct implements as Binary Search Tree (BST), which is a
 /// simple data structure for storing sorted data
@@ -38,29 +37,29 @@ where
     /// tree, and false otherwise
     pub fn search(&self, value: &T) -> bool {
         match &self.value {
-            Some(key) => {
-                match key.cmp(value) {
-                    Ordering::Equal => {
-                        // key == value
-                        true
-                    }
-                    Ordering::Greater => {
-                        // key > value
-                        match &self.left {
-                            Some(node) => node.search(value),
-                            None => false,
-                        }
+            // empty tree
+            None => false,
+            // non-empty tree
+            Some(key) => match value.cmp(key) {
+                // target == root's key
+                Ordering::Equal => true,
+                // target < root's key
+                Ordering::Less => {
+                    if let Some(node) = &self.left {
+                        node.search(value)
+                    } else {
+                        false
                     }
-                    Ordering::Less => {
-                        // key < value
-                        match &self.right {
-                            Some(node) => node.search(value),
-                            None => false,
-                        }
+                }
+                // target > root's key
+                Ordering::Greater => {
+                    if let Some(node) = &self.right {
+                        node.search(value)
+                    } else {
+                        false
                     }
                 }
-            }
-            None => false,
+            },
         }
     }
 
@@ -112,67 +111,68 @@ where
     /// Returns the largest value in this tree smaller than value
     pub fn floor(&self, value: &T) -> Option<&T> {
         match &self.value {
-            Some(key) => {
-                match key.cmp(value) {
-                    Ordering::Greater => {
-                        // key > value
-                        match &self.left {
-                            Some(node) => node.floor(value),
-                            None => None,
-                        }
+            // empty tree
+            None => None,
+            // non-empty tree
+            Some(key) => match value.cmp(key) {
+                // value == root's key
+                Ordering::Equal => Some(key),
+                // value < root's key
+                Ordering::Less => {
+                    if let Some(node) = &self.left {
+                        node.floor(value)
+                    } else {
+                        None
                     }
-                    Ordering::Less => {
-                        // key < value
-                        match &self.right {
-                            Some(node) => {
-                                let val = node.floor(value);
-                                match val {
-                                    Some(_) => val,
-                                    None => Some(key),
-                                }
-                            }
+                }
+                // value > root's key
+                Ordering::Greater => match &self.right {
+                    // right child is None
+                    None => Some(key),
+                    // right child is not None
+                    Some(node) => {
+                        let val = node.floor(value);
+                        match val {
                             None => Some(key),
+                            Some(_) => val,
                         }
                     }
-                    Ordering::Equal => Some(key),
-                }
-            }
-            None => None,
+                },
+            },
         }
     }
 
     /// Returns the smallest value in this tree larger than value
     pub fn ceil(&self, value: &T) -> Option<&T> {
         match &self.value {
-            Some(key) => {
-                match key.cmp(value) {
-                    Ordering::Less => {
-                        // key < value
-                        match &self.right {
-                            Some(node) => node.ceil(value),
-                            None => None,
-                        }
+            // empty tree
+            None => None,
+            // non-empty tree
+            Some(key) => match value.cmp(key) {
+                // value == root's key
+                Ordering::Equal => Some(key),
+                // value > root's key
+                Ordering::Greater => {
+                    if let Some(node) = &self.right {
+                        node.ceil(value)
+                    } else {
+                        None
                     }
-                    Ordering::Greater => {
-                        // key > value
-                        match &self.left {
-                            Some(node) => {
-                                let val = node.ceil(value);
-                                match val {
-                                    Some(_) => val,
-                                    None => Some(key),
-                                }
-                            }
+                }
+                // value < root's key
+                Ordering::Less => match &self.left {
+                    // left child is None
+                    None => Some(key),
+                    // left child is not None
+                    Some(node) => {
+                        let val = node.ceil(value);
+                        match val {
                             None => Some(key),
+                            Some(_) => val,
                         }
                     }
-                    Ordering::Equal => {
-                        // key == value
-                        Some(key)
-                    }
-                }
-            }
-            None => None,
+                },
+            },
         }
     }
 }
@@ -208,15 +208,15 @@ where
     type Item = &'a T;
 
     fn next(&mut self) -> Option<&'a T> {
-        if self.stack.is_empty() {
-            None
-        } else {
-            let node = self.stack.pop().unwrap();
-            if let Some(right_node) = &node.right {
-                self.stack.push(right_node.deref());
-                self.stack_push_left();
+        match self.stack.pop() {
+            None => None,
+            Some(node) => {
+                if let Some(right_node) = &node.right {
+                    self.stack.push(right_node);
+                    self.stack_push_left();
+                }
+                node.value.as_ref()
             }
-            node.value.as_ref()
         }
     }
 }