Rust 单链表实现

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

// 定义节点结构体
type SingleLink<T> = Option<Rc<RefCell<Node<T>>>>;

struct Node<T> {
    value: T,
    next: SingleLink<T>,
}

// 定义链表结构体
struct LinkedList<T> {
    head: SingleLink<T>,
    tail: SingleLink<T>,
    pub length: u32,
}

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

impl<T> LinkedList<T> {
    // 创建一个新的空链表
    pub fn new() -> LinkedList<T> {
        LinkedList {
            head: None,
            tail: None,
            length: 0,
        }
    }

    // 向链表末尾添加一个新元素
    pub fn append(&mut self, value: T) {
        let new = Node::new(value);
        match self.tail.take() {
            Some(old) => old.borrow_mut().next = Some(new.clone()),
            None => self.head = Some(new.clone()),
        };
        self.length += 1;
        self.tail = Some(new);
    }

    // 打印链表中的所有元素
    pub fn print(&self) 
    where T: Display{
        let mut current = self.head.clone();
        while let Some(rc) = current {
            let borrowed = rc.borrow();
            print!("{} ", borrowed.value);
            current = borrowed.next.clone();
        }
        println!();
    }
}

fn main() {
    let mut list = LinkedList::new();
    list.append(1);
    list.append(2);
    list.append(3);

    list.print();
}