为什么生锈可以直接使用==检查两棵树？

Question

问题：检查两种二元树是否相同。

我的解决方案：使用DFS。

但是

在此解决方案中，

// Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
//   pub val: i32,
//   pub left: Option<Rc<RefCell<TreeNode>>>,
//   pub right: Option<Rc<RefCell<TreeNode>>>,
// }
// 
// impl TreeNode {
//   #[inline]
//   pub fn new(val: i32) -> Self {
//     TreeNode {
//       val,
//       left: None,
//       right: None
//     }
//   }
// }
use std::rc::Rc;
use std::cell::RefCell;
impl Solution {
    pub fn is_same_tree(p: Option<Rc<RefCell<TreeNode>>>,
                        q: Option<Rc<RefCell<TreeNode>>>) -> bool {
        p == q
    }
}

生锈如何产生像这样的eq？

Answer 1

使用隐式递归DFS。您可以使用货物expand 或工具 - ＆gt;在操场上展开宏。 ＃[derive（partiaLeq）] 在您的示例输出中：

impl ::core::marker::StructuralPartialEq for TreeNode {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for TreeNode {
    #[inline]
    fn eq(&self, other: &TreeNode) -> bool {
        match *other {
            Self {
                val: ref __self_1_0,
                left: ref __self_1_1,
                right: ref __self_1_2,
            } => match *self {
                Self {
                    val: ref __self_0_0,
                    left: ref __self_0_1,
                    right: ref __self_0_2,
                } => {
                    (*__self_0_0) == (*__self_1_0)
                        && (*__self_0_1) == (*__self_1_1)
                        && (*__self_0_2) == (*__self_1_2)
                }
            },
        }
    }
    #[inline]
    fn ne(&self, other: &TreeNode) -> bool {
        match *other {
            Self {
                val: ref __self_1_0,
                left: ref __self_1_1,
                right: ref __self_1_2,
            } => match *self {
                Self {
                    val: ref __self_0_0,
                    left: ref __self_0_1,
                    right: ref __self_0_2,
                } => {
                    (*__self_0_0) != (*__self_1_0)
                        || (*__self_0_1) != (*__self_1_1)
                        || (*__self_0_2) != (*__self_1_2)
                }
            },
        }
    }
}

这可能令人生畏，但实际上与以下内容相同：

impl PartialEq for TreeNode {
    fn eq(&self, other: &TreeNode) -> bool {
        self.val == other.val && self.left == other.left && self.right == other.right
    }
}

因此，它首先比较该值，然后递归到 left ，它将再次比较其价值...直到我们完成左边并从权利开始。 DFS。它可能与您手中写的内容不同，因为它是递归的并且可能会炸毁堆栈，但仍然有效。