Skip to content

style/format-code: reduce code nesting #1043

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
Tellcts wants to merge 1 commit into
base: master
Choose a base branch
from
Open

style/format-code: reduce code nesting #1043

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
152 changes: 76 additions & 76 deletions src/data_structures/binary_search_tree.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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
Expand Down Expand Up @@ -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,
},
}
}

Expand Down Expand Up @@ -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,
},
},
}
}
}
Expand Down Expand Up @@ -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()
}
}
}
Expand Down