Question

我试图为队列实现dequeue函数，但我很困惑借阅检查器是如何工作的。我在这段代码中做错了什么？

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

type Link<T> = Option<Rc<RefCell<Node<T>>>>;

struct Node<T>{
    item: T,
    next: Link<T>
}
pub struct Queue<T>{
    first: Link<T>,
    last: Link<T>,
    length: usize
}

impl<T> Queue<T>{
    pub fn new() -> Queue<T> {
        Queue {
            first: None,
            last: None,
            length: 0
        }
    }
    pub fn is_empty(&self) -> bool {
        self.length == 0
    }
    pub fn size(&self) -> usize {
        self.length
    }
    pub fn enqueue(&mut self, item: T) {
        let temp = self.last.take();
        self.last = Some(Rc::new(RefCell::new(Node{
            item,
            next: None
        })));
        if self.is_empty() {
            self.first = self.last.clone();
        } else {
            let temp = temp.unwrap();
            temp.borrow_mut().next = self.last.clone();
        }
        self.length += 1;
    }
    pub fn dequeue(&mut self) -> Result<T, String>{
        if let Some(ref mut value) = self.first.take() {
            let mut temp = *(value.borrow_mut());
            let next = *(temp.next.unwrap().borrow_mut());
            let old_value = replace(&mut temp, next);
            return Ok(old_value.item);
        }
        Err("Queue is empty".to_owned())
    }
}

获得Some内部值的可变引用后，我想替换节点的next字段所引用的节点。我是否需要获取Some内的值的所有权？我甚至可以这样做吗？

Answer 1

以下是dequeue：

的实现

pub fn dequeue(&mut self) -> Result<T, String> {
    // First, disconnect `self.last` from the element it is pointing,
    // since it will have to be updated anyway. If there is no elemen in the
    // queue, we're done.
    let first = try!(self.first.take().ok_or("Queue is empty".to_owned()));
    // if there are two Rc's pointing to this node, then this must be the
    // only node, so `self.last` has to go
    if Rc::strong_count(&first) == 2 {
        self.last = None;
    }
    let first_node = Rc::try_unwrap(first).ok().expect(
        "This should be the only owner of the node"
    ).into_inner();
    self.first = first_node.next;
    self.length -= 1;
    Ok(first_node.item)
}

Here is the complete code。我还添加了dequeue_back来使这几乎成为双端队列和一些测试。

我在这段代码中为队列实现`dequeue`函数做错了什么？

1 个答案: