Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit dac1768

Browse files
feat: update solutions to lc problems: No.2331,2974,3011 (doocs#3258)
1 parent 8001ba6 commit dac1768

File tree

24 files changed

+172
-489
lines changed

24 files changed

+172
-489
lines changed

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

Lines changed: 41 additions & 161 deletions
Original file line numberDiff line numberDiff line change
@@ -82,14 +82,12 @@ OR 运算节点的值为 True OR False = True 。
8282

8383
我们可以使用递归的方式来求解本题。
8484

85-
对于当前节点 `root`:
85+
对于当前节点 $\textit{root}$:
8686

87-
- 如果其左右孩子都为空,说明是叶子节点,此时判断其值是否为 1ドル,ドル如果是,则返回 `true`,否则返回 `false`。
88-
- 否则,对其左右孩子分别递归求解,得到其左右孩子的值 $l$ 和 $r$。然后根据当前节点值的不同,分别进行如下操作:
89-
- 如果当前节点值为 2ドル,ドル则返回 `l or r`。
90-
- 如果当前节点值为 3ドル,ドル则返回 `l && r`。
87+
- 如果其左孩子为空,说明当前节点是叶子节点。如果当前节点的值为 1ドル,ドル则返回 $\text{true},ドル否则返回 $\text{false}$;
88+
- 如果当前节点的值为 2ドル,ドル则返回其左孩子和右孩子的递归结果的逻辑或,否则返回其左孩子和右孩子的递归结果的逻辑与。
9189

92-
时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 为二叉树节点个数。
90+
时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点个数。
9391

9492
<!-- tabs:start -->
9593

@@ -104,13 +102,10 @@ OR 运算节点的值为 True OR False = True 。
104102
# self.right = right
105103
class Solution:
106104
def evaluateTree(self, root: Optional[TreeNode]) -> bool:
107-
def dfs(root):
108-
if root.left is None and root.right is None:
109-
return bool(root.val)
110-
l, r = dfs(root.left), dfs(root.right)
111-
return (l or r) if root.val == 2 else (l and r)
112-
113-
return dfs(root)
105+
if root.left is None:
106+
return bool(root.val)
107+
op = or_ if root.val == 2 else and_
108+
return op(self.evaluateTree(root.left), self.evaluateTree(root.right))
114109
```
115110

116111
#### Java
@@ -133,18 +128,13 @@ class Solution:
133128
*/
134129
class Solution {
135130
public boolean evaluateTree(TreeNode root) {
136-
return dfs(root);
137-
}
138-
139-
private boolean dfs(TreeNode root) {
140-
if (root.left == null && root.right == null) {
131+
if (root.left == null) {
141132
return root.val == 1;
142133
}
143-
boolean l = dfs(root.left), r = dfs(root.right);
144134
if (root.val == 2) {
145-
return l || r;
135+
return evaluateTree(root.left) || evaluateTree(root.right);
146136
}
147-
return l && r;
137+
return evaluateTree(root.left) && evaluateTree(root.right);
148138
}
149139
}
150140
```
@@ -166,14 +156,13 @@ class Solution {
166156
class Solution {
167157
public:
168158
bool evaluateTree(TreeNode* root) {
169-
return dfs(root);
170-
}
171-
172-
bool dfs(TreeNode* root) {
173-
if (!root->left && !root->right) return root->val;
174-
bool l = dfs(root->left), r = dfs(root->right);
175-
if (root->val == 2) return l || r;
176-
return l && r;
159+
if (!root->left) {
160+
return root->val;
161+
}
162+
if (root->val == 2) {
163+
return evaluateTree(root->left) || evaluateTree(root->right);
164+
}
165+
return evaluateTree(root->left) && evaluateTree(root->right);
177166
}
178167
};
179168
```
@@ -190,18 +179,14 @@ public:
190179
* }
191180
*/
192181
func evaluateTree(root *TreeNode) bool {
193-
var dfs func(*TreeNode) bool
194-
dfs = func(root *TreeNode) bool {
195-
if root.Left == nil && root.Right == nil {
196-
return root.Val == 1
197-
}
198-
l, r := dfs(root.Left), dfs(root.Right)
199-
if root.Val == 2 {
200-
return l || r
201-
}
202-
return l && r
182+
if root.Left == nil {
183+
return root.Val == 1
184+
}
185+
if root.Val == 2 {
186+
return evaluateTree(root.Left) || evaluateTree(root.Right)
187+
} else {
188+
return evaluateTree(root.Left) && evaluateTree(root.Right)
203189
}
204-
return dfs(root)
205190
}
206191
```
207192

@@ -224,7 +209,7 @@ func evaluateTree(root *TreeNode) bool {
224209

225210
function evaluateTree(root: TreeNode | null): boolean {
226211
const { val, left, right } = root;
227-
if (left == null) {
212+
if (left === null) {
228213
return val === 1;
229214
}
230215
if (val === 2) {
@@ -257,20 +242,23 @@ function evaluateTree(root: TreeNode | null): boolean {
257242
// }
258243
use std::cell::RefCell;
259244
use std::rc::Rc;
260-
impl Solution {
261-
fn dfs(root: &Option<Rc<RefCell<TreeNode>>>) -> bool {
262-
let root = root.as_ref().unwrap().as_ref().borrow();
263-
if root.left.is_none() {
264-
return root.val == 1;
265-
}
266-
if root.val == 2 {
267-
return Self::dfs(&root.left) || Self::dfs(&root.right);
268-
}
269-
Self::dfs(&root.left) && Self::dfs(&root.right)
270-
}
271245

246+
impl Solution {
272247
pub fn evaluate_tree(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
273-
Self::dfs(&root)
248+
match root {
249+
Some(node) => {
250+
let node = node.borrow();
251+
if node.left.is_none() {
252+
return node.val == 1;
253+
}
254+
if node.val == 2 {
255+
return Self::evaluate_tree(node.left.clone())
256+
|| Self::evaluate_tree(node.right.clone());
257+
}
258+
Self::evaluate_tree(node.left.clone()) && Self::evaluate_tree(node.right.clone())
259+
}
260+
None => false,
261+
}
274262
}
275263
}
276264
```
@@ -301,112 +289,4 @@ bool evaluateTree(struct TreeNode* root) {
301289
302290
<!-- solution:end -->
303291
304-
<!-- solution:start -->
305-
306-
### 方法二
307-
308-
<!-- tabs:start -->
309-
310-
#### Python3
311-
312-
```python
313-
# Definition for a binary tree node.
314-
# class TreeNode:
315-
# def __init__(self, val=0, left=None, right=None):
316-
# self.val = val
317-
# self.left = left
318-
# self.right = right
319-
class Solution:
320-
def evaluateTree(self, root: Optional[TreeNode]) -> bool:
321-
if root.left is None:
322-
return bool(root.val)
323-
l = self.evaluateTree(root.left)
324-
r = self.evaluateTree(root.right)
325-
return l or r if root.val == 2 else l and r
326-
```
327-
328-
#### Java
329-
330-
```java
331-
/**
332-
* Definition for a binary tree node.
333-
* public class TreeNode {
334-
* int val;
335-
* TreeNode left;
336-
* TreeNode right;
337-
* TreeNode() {}
338-
* TreeNode(int val) { this.val = val; }
339-
* TreeNode(int val, TreeNode left, TreeNode right) {
340-
* this.val = val;
341-
* this.left = left;
342-
* this.right = right;
343-
* }
344-
* }
345-
*/
346-
class Solution {
347-
public boolean evaluateTree(TreeNode root) {
348-
if (root.left == null) {
349-
return root.val == 1;
350-
}
351-
boolean l = evaluateTree(root.left);
352-
boolean r = evaluateTree(root.right);
353-
return root.val == 2 ? l || r : l && r;
354-
}
355-
}
356-
```
357-
358-
#### C++
359-
360-
```cpp
361-
/**
362-
* Definition for a binary tree node.
363-
* struct TreeNode {
364-
* int val;
365-
* TreeNode *left;
366-
* TreeNode *right;
367-
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
368-
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
369-
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
370-
* };
371-
*/
372-
class Solution {
373-
public:
374-
bool evaluateTree(TreeNode* root) {
375-
if (!root->left) {
376-
return root->val;
377-
}
378-
bool l = evaluateTree(root->left);
379-
bool r = evaluateTree(root->right);
380-
return root->val == 2 ? l or r : l and r;
381-
}
382-
};
383-
```
384-
385-
#### Go
386-
387-
```go
388-
/**
389-
* Definition for a binary tree node.
390-
* type TreeNode struct {
391-
* Val int
392-
* Left *TreeNode
393-
* Right *TreeNode
394-
* }
395-
*/
396-
func evaluateTree(root *TreeNode) bool {
397-
if root.Left == nil {
398-
return root.Val == 1
399-
}
400-
l, r := evaluateTree(root.Left), evaluateTree(root.Right)
401-
if root.Val == 2 {
402-
return l || r
403-
}
404-
return l && r
405-
}
406-
```
407-
408-
<!-- tabs:end -->
409-
410-
<!-- solution:end -->
411-
412292
<!-- problem:end -->

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /