feat: add solutions to lc problem: No.2331

No.2331.Evaluate Boolean Binary Tree

Author: YangFong

solution/2300-2399/2331.Evaluate Boolean Binary Tree/README.md

@@ -302,8 +302,8 @@ func evaluateTree(root *TreeNode) bool {
 
 function evaluateTree(root: TreeNode | null): boolean {
     const { val, left, right } = root;
-    if (left == null && right == null) {
-        return !!val;
+    if (left == null) {
+        return val === 1;
     }
     if (val === 2) {
         return evaluateTree(left) || evaluateTree(right);
@@ -312,6 +312,69 @@ function evaluateTree(root: TreeNode | null): boolean {
 }
 ```
 
+### **Rust**
+
+```rust
+// 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 {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) -> bool {
+        let root = root.as_ref().unwrap().as_ref().borrow();
+        if root.left.is_none() {
+            return root.val == 1;
+        }
+        if root.val == 2 {
+            return Self::dfs(&root.left) || Self::dfs(&root.right);
+        }
+        Self::dfs(&root.left) && Self::dfs(&root.right)
+    }
+
+    pub fn evaluate_tree(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        Self::dfs(&root)
+    }
+}
+```
+
+### **C**
+
+```c
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+bool evaluateTree(struct TreeNode *root) {
+    if (!root->left) {
+        return root->val == 1;
+    }
+    if (root->val == 2) {
+        return evaluateTree(root->left) || evaluateTree(root->right);
+    }
+    return evaluateTree(root->left) && evaluateTree(root->right);
+}
+```
+
 ### **...**
 
 ```

solution/2300-2399/2331.Evaluate Boolean Binary Tree/README_EN.md

@@ -279,8 +279,8 @@ func evaluateTree(root *TreeNode) bool {
 
 function evaluateTree(root: TreeNode | null): boolean {
     const { val, left, right } = root;
-    if (left == null && right == null) {
-        return !!val;
+    if (left == null) {
+        return val === 1;
     }
     if (val === 2) {
         return evaluateTree(left) || evaluateTree(right);
@@ -289,6 +289,69 @@ function evaluateTree(root: TreeNode | null): boolean {
 }
 ```
 
+### **Rust**
+
+```rust
+// 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 {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) -> bool {
+        let root = root.as_ref().unwrap().as_ref().borrow();
+        if root.left.is_none() {
+            return root.val == 1;
+        }
+        if root.val == 2 {
+            return Self::dfs(&root.left) || Self::dfs(&root.right);
+        }
+        Self::dfs(&root.left) && Self::dfs(&root.right)
+    }
+
+    pub fn evaluate_tree(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        Self::dfs(&root)
+    }
+}
+```
+
+### **C**
+
+```c
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+bool evaluateTree(struct TreeNode *root) {
+    if (!root->left) {
+        return root->val == 1;
+    }
+    if (root->val == 2) {
+        return evaluateTree(root->left) || evaluateTree(root->right);
+    }
+    return evaluateTree(root->left) && evaluateTree(root->right);
+}
+```
+
 ### **...**
 
 ```

solution/2300-2399/2331.Evaluate Boolean Binary Tree/Solution.c

@@ -0,0 +1,17 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+bool evaluateTree(struct TreeNode *root) {
+    if (!root->left) {
+        return root->val == 1;
+    }
+    if (root->val == 2) {
+        return evaluateTree(root->left) || evaluateTree(root->right);
+    }
+    return evaluateTree(root->left) && evaluateTree(root->right);
+}

solution/2300-2399/2331.Evaluate Boolean Binary Tree/Solution.rs

@@ -0,0 +1,36 @@
+// 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 {
+    fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) -> bool {
+        let root = root.as_ref().unwrap().as_ref().borrow();
+        if root.left.is_none() {
+            return root.val == 1;
+        }
+        if root.val == 2 {
+            return Self::dfs(&root.left) || Self::dfs(&root.right);
+        }
+        Self::dfs(&root.left) && Self::dfs(&root.right)
+    }
+
+    pub fn evaluate_tree(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        Self::dfs(&root)
+    }
+}

solution/2300-2399/2331.Evaluate Boolean Binary Tree/Solution.ts

@@ -14,8 +14,8 @@
 
 function evaluateTree(root: TreeNode | null): boolean {
     const { val, left, right } = root;
-    if (left == null && right == null) {
-        return !!val;
+    if (left == null) {
+        return val === 1;
     }
     if (val === 2) {
         return evaluateTree(left) || evaluateTree(right);