使用Rc<RefCell<..>>实现二进制搜索树时的生命周期问题

use std::rc::Rc;
use std::cell::RefCell;

#[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,
        }
    }
}

pub struct BinarySearchTree {
    root: Option<Rc<RefCell<TreeNode>>>,
}

impl BinarySearchTree {
    pub fn new() -> Self {
        BinarySearchTree { root: None }
    }

    pub fn insert(&mut self, val: i32) {
        let new_node = Rc::new(RefCell::new(TreeNode::new(val)));
        if let Some(root) = &self.root {
            self.insert_helper(root.clone(), new_node);
        } else {
            self.root = Some(new_node);
        }
    }

    fn insert_helper(&self, node: Rc<RefCell<TreeNode>>, new_node: Rc<RefCell<TreeNode>>) {
        let mut node_borrow = node.borrow_mut();
        if new_node.borrow().val < node_borrow.val {
            if let Some(left) = &node_borrow.left {
                self.insert_helper(left.clone(), new_node);
            } else {
                node_borrow.left = Some(new_node);
            }
        } else {
            if let Some(right) = &node_borrow.right {
                self.insert_helper(right.clone(), new_node);
            } else {
                node_borrow.right = Some(new_node);
            }
        }
    }
}

fn main() {
    let mut bst = BinarySearchTree::new();
    bst.insert(5);
    bst.insert(3);
    bst.insert(7);
    bst.insert(2);
    bst.insert(4);
    bst.insert(6);
    bst.insert(8);

    println!("{:#?}", bst.root);
}