leetcode简单题20 N.101 对称二叉树 rust描述

最新推荐文章于 2024-09-09 22:01:06 发布

独好紫罗兰

最新推荐文章于 2024-09-09 22:01:06 发布

阅读量209

点赞数 1

分类专栏： rust-leetcode简单题文章标签： leetcode rust 算法

本文链接：https://blog.csdn.net/BECOMEviolet/article/details/140335173

版权

rust-leetcode简单题专栏收录该内容

27 篇文章 0 订阅

订阅专栏

// [1,2,2,3,4,4,3] true
// [1,2,2,null,3,null,3] false
use std::rc::Rc;
use std::cell::RefCell;
#[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
    }
  }
}
// 递归
pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
    is_mirror(&root, &root)
}
// 递归的辅助函数，
fn is_mirror(
    left: &Option<Rc<RefCell<TreeNode>>>,
    right: &Option<Rc<RefCell<TreeNode>>>,
) -> bool {
    match (left, right) {
        (Some(left_node), Some(right_node)) => {
            let left_node = left_node.borrow();
            let right_node = right_node.borrow();
            left_node.val == right_node.val
                && is_mirror(&left_node.left, &right_node.right)
                && is_mirror(&left_node.right, &right_node.left)
        }
        (None, None) => true,
        _ => false,
    }
}
use std::collections::VecDeque;
// 迭代
pub fn is_symmetric2(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
    if root.is_none() {
        return true;
    }

    let mut queue = VecDeque::new();
    queue.push_back(root.clone());
    queue.push_back(root.clone());

    while !queue.is_empty() {
        let left = queue.pop_front().unwrap();
        let right = queue.pop_front().unwrap();

        if left.is_none() && right.is_none() {
            continue;
        }

        if left.is_none() || right.is_none() {
            return false;
        }

        let left_node = left.as_ref().unwrap().borrow();
        let right_node = right.as_ref().unwrap().borrow();

        if left_node.val != right_node.val {
            return false;
        }

        queue.push_back(left_node.left.clone());
        queue.push_back(right_node.right.clone());
        queue.push_back(left_node.right.clone());
        queue.push_back(right_node.left.clone());
    }

    true
}
fn main() {
    // 根据 [1,2,2,3,4,4,3] true 编写测试用例
    let tree = Some(Rc::new(RefCell::new(TreeNode {
        val:1,
        left:Some(Rc::new(RefCell::new(TreeNode {
            val:2,
            left:Some(Rc::new(RefCell::new(TreeNode {
                val:3,
                left:None,
                right:None,
            }))),
            right:Some(Rc::new(RefCell::new(TreeNode {
                val:4,
                left:None,
                right:None,
            }))),
        }))),
        right:Some(Rc::new(RefCell::new(TreeNode {
            val:2,
            left:Some(Rc::new(RefCell::new(TreeNode {
                val:4,
                left:None,
                right:None,
            }))),
            right:Some(Rc::new(RefCell::new(TreeNode {
                val:3,
                left:None,
                right:None,
            }))),
        }))),
    })));
    assert_eq!(is_symmetric(tree.clone()), true);
    assert_eq!(is_symmetric2(tree.clone()), true);
}