Rust：实现 AVL 树和错误：线程“main”在“已借用：BorrowMutError”处恐慌

Question

我有以下树结构：

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

type AVLTree<T> = Option<Rc<RefCell<TreeNode<T>>>>;

#[derive(Debug, PartialEq, Clone)]
struct TreeSet<T: Ord> {
    root: AVLTree<T>,
}

impl<T: Ord> TreeSet<T> {
    fn new() -> Self {
        Self { 
            root: None 
        }
    }

    fn insert(&mut self, value: T) -> bool {
        let current_tree = &mut self.root;

        while let Some(current_node) = current_tree {

            let node_key = &current_node.borrow().key;
          
            match node_key.cmp(&value) {
                Ordering::Less => { let current_tree = &mut current_node.borrow_mut().right; },
                Ordering::Equal => {
                    return false;
                }
                Ordering::Greater => { let current_tree = &mut current_node.borrow_mut().left; },
            }
        }

        *current_tree = Some(Rc::new(RefCell::new(TreeNode {
            key: value,
            left: None,
            right: None,
            parent: None
        })));

        true
    }

}


#[derive(Clone, Debug, PartialEq)]
struct TreeNode<T: Ord> {
    pub key: T,
    pub parent: AVLTree<T>,
    left: AVLTree<T>,
    right: AVLTree<T>,
}


fn main() {
    let mut new_avl_tree: TreeSet<u32> = TreeSet::new();
    new_avl_tree.insert(3);
    new_avl_tree.insert(5);
    println!("Tree: {:#?}", &new_avl_tree);
}

使用cargo build很好，但是当我运行cargo run ，出现以下错误：

线程“main”在“已借用：BorrowMutError”，src\\libcore\\result.rs:1165:5 处恐慌

注意：使用RUST_BACKTRACE=1环境变量运行以显示回溯。 错误：进程没有

成功退出： target\\debug\\avl-tree.exe （退出代码：101）

如果我只是调用insert(3) ，它会很好并且我的树被正确打印。 不过，如果我insert(5)后insert(3)我会得到这个错误。

我该如何解决？

Answer 1

由于语言中的内存安全规则，手动实现链表、树、图等数据结构不是新手的任务。 我建议您阅读Too Many Linked Lists教程，其中讨论了如何以正确的方式在 Rust 中实现安全和不安全的链表。

另请阅读名称阴影。 你的错误是在一个循环中你试图借用可变的东西，而这些东西已经被借为不可变的。

let node_key = &current_node.borrow().key; // Borrow as immutable

match node_key.cmp(&value) {
    Ordering::Less => { let current_tree = &mut current_node.borrow_mut().right; }, // Create a binding which will be immediately deleted and borrow as mutable.

我建议你阅读Rust 书来学习Rust 。

Answer 2

首先让我们更正您的算法。 以下几行不正确：

let current_tree = &mut current_node.borrow_mut().right;
...
let current_tree = &mut current_node.borrow_mut().left;

两者都不会为current_tree重新分配值，而是创建一个新的（未使用的）值（@Inline 将其称为名称阴影）。 删除let并使current_tree mut 。

现在我们得到一个编译器错误temporary value dropped while borrowed 。 可能编译器错误消息确实误导了您。 它告诉你使用let来增加生命周期，如果你在同一个范围内使用结果，这将是正确的，但是没有 let 可以增加超出范围的生命周期。

问题是您不能传递对循环拥有的值的引用（如current_node.borrow_mut.right ）。 所以最好使用current_tree作为拥有的变量。 可悲的是，这意味着您代码中的许多巧妙技巧将不再起作用。

代码中的另一个问题是多次借用问题（您最初的运行时警告是关于此的）。 你不能在没有恐慌的情况下在同一个RefCell上调用borrow_mut() borrow()和borrow_mut() （这是RefCell的目的）。

因此，在发现代码中的问题后，我对如何编写代码产生了兴趣。 现在它写好了，我认为分享它是公平的： fn insert(&mut self, value: T) -> bool { if let None = self.root { self.root = TreeSet::root(value) ; 返回真； 让 mut current_tree = self.root.clone();

  while let Some(current_node) = current_tree {
    let mut borrowed_node = current_node.borrow_mut();
    match borrowed_node.key.cmp(&value) {
      Ordering::Less => {
        if let Some(next_node) = &borrowed_node.right {
          current_tree = Some(next_node.clone());
        } else {
          borrowed_node.right = current_node.child(value);
          return true;
        }
      }
      Ordering::Equal => {
        return false;
      }
      Ordering::Greater => {
        if let Some(next_node) = &borrowed_node.left {
          current_tree = Some(next_node.clone());
        } else {
          borrowed_node.left = current_node.child(value);
          return true;
        }
      }
    };
  }
  true
}

//...

trait NewChild<T: Ord> {
  fn child(&self, value: T) -> AVLTree<T>;
}
impl<T: Ord> NewChild<T> for Rc<RefCell<TreeNode<T>>> {
  fn child(&self, value: T) -> AVLTree<T> {
    Some(Rc::new(RefCell::new(TreeNode {
      key: value,
      left: None,
      right: None,
      parent: Some(self.clone()),
    })))
  }
}

必须编写两个方法child(value:T)和root(value:T)才能进行编译。