Pointers 创建可变二叉树时未定义类型名称T

我对生锈还不熟悉，为了练习，我正在构建一个简单的通用二叉树。这就是我在C中创建一个的方法++

模板
结构体类型
{
T数据；
节点*父节点；
节点*左；
节点*右；
};
模板
结构二叉树
{
节点*根；
};

但是，Rust中的相同（ish）代码似乎不起作用：

use std::ptr;

struct Node<T> {
    data: T,
    left: &Node<T>,
    right: &Node<T>,
    parent: &Node<T>,
}

struct Tree<T> {
    root: &Node<T>,
}

impl Tree<T> {
    pub fn new() -> Tree<T> {
        Tree { root: ptr::null() }
    }

    pub fn insert(&self, value: T) {
        if root.is_null() {
            self.root = Node {
                data: value,
                left: ptr::null(),
                right: ptr::null(),
                parent: ptr::null(),
            };
        }
    }
}

fn main() {
    println!("Hello, world!");
}

使用std:：ptr；
结构节点{
数据：T，
左：&节点，
右：&节点，
父节点：&节点，
}
结构树{
根：&节点，
}
impl树{
pub fn new（）->树{
树{root:ptr:：null（）}
}
发布fn插入（&self，值：T）{
如果root.is_null（）{
self.root=节点{
数据：价值，
左：ptr:：null（），
右：ptr:：null（），
父级：ptr:：null（），
};
}
}
}
fn main（）{
println！（“你好，世界！”）；
}

下面是错误：

错误[E0412]：类型名称'T'未定义或不在范围内
-->src/main.rs:14:15
|
14 | impl树{
|^未定义或不在范围内
|
=帮助：在您的项目中找不到名为“T”的候选人；可能您拼错了名称或忘记导入外部板条箱？
错误[E0412]：类型名称'T'未定义或不在范围内
-->src/main.rs:15:30
|
15 | pub fn new（）->树{
|^未定义或不在范围内
|
=帮助：在您的项目中找不到名为“T”的候选人；可能您拼错了名称或忘记导入外部板条箱？
错误[E0412]：类型名称'T'未定义或不在范围内
-->src/main.rs:19:37
|
19 |发布fn插入（&self，值：T）{
|^未定义或不在范围内
|
=帮助：在您的项目中找不到名为“T”的候选人；可能您拼错了名称或忘记导入外部板条箱？
错误[E0425]：未解析名称“root”。您是指“self.root”吗？
-->src/main.rs:20:16
|
20 |如果root.is_null（）{
|                ^^^^
错误[E0106]：缺少生存期说明符
-->src/main.rs:5:15
|
5 |左：&节点，
|^预期寿命参数
错误[E0106]：缺少生存期说明符
-->src/main.rs:6:16
|
6 |右：&节点，
|^预期寿命参数
错误[E0106]：缺少生存期说明符
-->src/main.rs:7:17
|
7 |父节点：&节点，
|^预期寿命参数
错误[E0106]：缺少生存期说明符
-->src/main.rs:11:15
|
11 |根：&节点，
|^预期寿命参数

---

我真的不明白这是怎么回事。我真的不明白Rust的指针是如何工作的。

在这种情况下，您有一个基本语法错误，应该是

impl<T> Tree<T>

因此，您在那里使用

T:'a

，结果是：

use std::ptr;

struct Node<'a, T: 'a> {
    data: T,
    left: &'a Node<'a, T>,
    right: &'a Node<'a, T>,
    parent: &'a Node<'a, T>,
}

struct Tree<'a, T: 'a> {
    root: &'a Node<'a, T>,
}

impl<'a, T> Tree<'a, T> {
    pub fn new() -> Tree<'a, T> {
        Tree { root: ptr::null() }
    }

    pub fn insert(&self, value: T) {
        if self.root.is_null() {
            self.root = Node {
                data: value,
                left: ptr::null(),
                right: ptr::null(),
                parent: ptr::null(),
            };
        }
    }
}

fn main() {
    println!("Hello, world!");
}

这是因为

ptr:：null（）

返回原始指针，但您已经声明数据结构使用引用

好了，我就说到这里了。让我们回到你的问题上来

我对生锈还不熟悉，为了练习，我正在构建一个简单的通用二叉树

---

我建议你除了写一个数据结构以外，应该考虑一些别的东西。它们不是简单的生锈。如果你还想做这个方法，我可以推荐。

我终于找到了一个方法。我用<代码> STD:：可选的< /C> >代替No.St::PtR <代码>节点结构，它像C指针一样工作。

struct Node<T> {
    id: u32,
    data: T,
    left: Option<Box<Node<T>>>,
    right: Option<Box<Node<T>>>,
    parent: Option<Box<Node<T>>>,
}

struct Tree<T> {
    root: Option<Node<T>>,
}

impl<T> Node<T> {
    pub fn new(value: Option<T>,
               left: Option<Box<Node<T>>>,
               right: Option<Box<Node<T>>>,
               parent: Option<Box<Node<T>>>)
               -> Node<T> {
        Node {
            data: value.unwrap(),
            left: left,
            right: right,
            parent: parent,
        }
    }
}

impl<T> Tree<T> {
    pub fn new() -> Tree<T> {
        Tree { root: None }
    }

    pub fn insert(&mut self, value: T) {
        match self.root {
            Some(ref n) => {
                println!("Root is not empty");
            }
            None => {
                println!("Root is empty");
                self.root = Some(Node::new(Some(value), None, None, None));
            }
        }
    }
}

fn main() {
    println!("Hello, world!");

    let mut tree: Tree<i32> = Tree::new();
    tree.insert(42);
}

struct节点{
id:u32，
数据：T，
左：选项，
右：选项，
家长：选择，
}
结构树{
根：选项，
}
impl节点{
发布fn新（值：选项，
左：选项，
右：选项，
家长：选择）
->节点{
节点{
数据：value.unwrap（），
左:左,，
对:对，
家长：家长，
}
}
}
impl树{
pub fn new（）->树{
树{根：无}
}
发布fn插入（&mut self，值：T）{
匹配self.root{
一些（参考n）=>{
println！（“根不是空的”）；
}
无=>{
println！（“根为空”）；
self.root=Some（节点：：new（Some（value），None，None，None））；
}
}
}
}
fn main（）{
println！（“你好，世界！”）；
让mut-tree:tree=tree:：new（）；
插入（42）；
}

我找到了答案（见下面的帖子），但感谢您的帮助，

Box

是一个指针，它拥有它所指向的对象。拥有子节点的节点听起来不错，但节点不能拥有它的父节点。父指针使您的数据结构像图形一样，它有一个引用循环，Box和Rust的常规引用都不能处理这个问题。它相对来说比较直截了当ard使用原始指针作为父指针。