Rust二叉搜索树

节点的结构

#[derive(Debug, Clone)]
struct TreeNode<T> {
    pub data: T,
    pub left: Option<Box<TreeNode<T>>>,
    pub right: Option<Box<TreeNode<T>>>,
}

impl<T> TreeNode<T>
where
    T: PartialOrd + Display + Copy,
{
    #[inline]
    fn new(data: T) -> Self {
        TreeNode {
            data,
            left: None,
            right: None,
        }
    }
}

插入

  fn insert(&mut self, data: T) {
        if data < self.data {
            if let Some(left) = &mut self.left {
                left.insert(data);
            } else {
                self.left = Some(Box::new(TreeNode::new(data)));
            }
        } else if data > self.data {
            if let Some(right) = &mut self.right {
                right.insert(data);
            } else {
                self.right = Some(Box::new(TreeNode::new(data)));
            }
        } else { 
        }
    }

查找

按目标查找

    fn find(&mut self, target: T) -> Option<&mut Self> {
        if target < self.data {
            if let Some(left) = &mut self.left {
                return left.find(target);
            } else {
                // not found
                return None;
            }
        } else if target > self.data {
            if let Some(right) = &mut self.right {
                return right.find(target);
            } else {
                // not found
                return None;
            }
        } else {
            return Some(self);
        }
    }

查找最大值最小值

 fn find_min(&self) -> Option<&Self> {
        if self.left.is_some() {
            return self.left.as_ref().unwrap().find_min();
        } else {
            return Some(self);
        }
    }
    fn find_max(&self) -> Option<&Self> {
        if self.right.is_some() {
            return self.right.as_ref().unwrap().find_max();
        } else {
            return Some(self);
        }
    }

获取节点的数量和树的深度

 pub fn get_node_num(&self) -> usize {
        let left = match &self.left {
            None => 0,
            Some(node) => node.get_node_num(),
        };
        let right = match &self.right {
            None => 0,
            Some(node) => node.get_node_num(),
        };
        return 1 + left + right;
    }
    pub fn get_depth(&self) -> usize {
        let left = match &self.left {
            None => 0,
            Some(node) => node.get_depth(),
        };
        let right = match &self.right {
            None => 0,
            Some(node) => node.get_depth(),
        };
        if left > right {
            return left + 1;
        } else {
            return right + 1;
        }
    }

遍历

前序遍历

   fn pre_order(&self) {
        println!("{}", self.data);
        if let Some(left) = &self.left {
            left.pre_order()
        }
        if let Some(right) = &self.right {
            right.pre_order()
        }
    }

中序遍历

输出的结果是排好序的

  fn infix_order(&self) {
        if let Some(left) = &self.left {
            left.infix_order()
        }
        println!("{}", self.data);
        if let Some(right) = &self.right {
            right.infix_order()
        }
    }

后序遍历

 fn after_order(&self) {
        if let Some(left) = &self.left {
            left.after_order()
        }
        if let Some(right) = &self.right {
            right.after_order()
        }
        println!("{}", self.data);
    }

层序遍历

通过 vec模拟队列来实现

 fn level_order(&self) {
        let mut queue = Vec::new(); //初始化队列
        queue.push(self); //根结点入队列
        while !queue.is_empty() {
            let a = queue.remove(0);
            println!("{}", a.data);
            if let Some(b) = &a.left {
                queue.push(b.as_ref());
            }
            if let Some(b) = &a.right {
                queue.push(b.as_ref());
            }
        }
    }

节点删除不会，如果您会的话，可以在评论区告诉我吗？

源码地址