too-many-lists/production-unsafe-deque/layout

[giscus[bot]]

too-many-lists/production-unsafe-deque/layout

https://course.rs/too-many-lists/production-unsafe-deque/layout.html

[KINGFIOX]

这鸡汤十分的珍贵，直接来吧！！！

[haydenzhourepo]

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

pub struct List<T> {
    head: Link<T>,
    tail: Link<T>,
}

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

struct Node<T> {
    elem: T,
    next: Link<T>,
    prev: Link<T>,
}

impl<T> Node<T> {
    fn new(elem: T) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(Node {
            elem: elem,
            prev: None,
            next: None,
        }))
    }
}

impl<T> List<T> {
    pub fn new() -> Self {
        List {
            head: None,
            tail: None,
        }
    }

    pub fn push_front(&mut self, elem: T) {
        let node = Node::new(elem);

        let temp = self.head.take();
        if let Some(n) = temp {
            (*node).borrow_mut().next.replace(Rc::clone(&n));
            (*n).borrow_mut().prev.replace(Rc::clone(&node));
        }

        self.head.replace(Rc::clone(&node));

        if let None = self.tail {
            self.tail.replace(Rc::clone(&node));
        }
    }

    pub fn pop_front(&mut self) -> Option<T> {
        match self.head.take() {
            None => None,
            Some(node) => {
                match (*node).borrow_mut().next.take() {
                    None => {
                        self.tail = None;
                    }
                    Some(n) => {
                        self.head.replace(Rc::clone(&n));
                        (*n).borrow_mut().prev.take();
                    }
                }

                Some(Rc::try_unwrap(node).ok().unwrap().into_inner().elem)
            }
        }
    }
}

[naosense]

没看懂传统方法和虚拟节点方法在讨论啥

[max201904]

不实现 Drop 时, long_list 测试不会栈溢出, 因为 next 和 prev 自成一条循环引用, 会导致内存泄漏. 必须实现 Drop 防止内存泄漏