Skip to content

Commit 87b4bfe

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0965.Univalued Binary Tree
1 parent f1240f5 commit 87b4bfe

File tree

6 files changed

+297
-37
lines changed

6 files changed

+297
-37
lines changed

‎solution/0900-0999/0965.Univalued Binary Tree/README.md

+106-2
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,6 @@
3737
<li>每个节点的值都是整数，范围为&nbsp;<code>[0, 99]</code>&nbsp;。</li>
3838
</ol>
3939

40-
4140
## 解法
4241

4342
<!-- 这里可写通用的实现逻辑 -->
@@ -49,15 +48,120 @@
4948
<!-- 这里可写当前语言的特殊实现逻辑 -->
5049

5150
```python
52-
51+
# Definition for a binary tree node.
52+
# class TreeNode:
53+
# def __init__(self, val=0, left=None, right=None):
54+
# self.val = val
55+
# self.left = left
56+
# self.right = right
57+
class Solution:
58+
def isUnivalTree(self, root: TreeNode) -> bool:
59+
def dfs(root):
60+
if root is None:
61+
return True
62+
if root.val != self.val:
63+
return False
64+
return dfs(root.left) and dfs(root.right)
65+
66+
self.val = root.val
67+
return dfs(root)
5368
```
5469

5570
### **Java**
5671

5772
<!-- 这里可写当前语言的特殊实现逻辑 -->
5873

5974
```java
75+
/**
76+
* Definition for a binary tree node.
77+
* public class TreeNode {
78+
* int val;
79+
* TreeNode left;
80+
* TreeNode right;
81+
* TreeNode() {}
82+
* TreeNode(int val) { this.val = val; }
83+
* TreeNode(int val, TreeNode left, TreeNode right) {
84+
* this.val = val;
85+
* this.left = left;
86+
* this.right = right;
87+
* }
88+
* }
89+
*/
90+
class Solution {
91+
private int val;
92+
93+
public boolean isUnivalTree(TreeNode root) {
94+
val = root.val;
95+
return dfs(root);
96+
}
97+
98+
private boolean dfs(TreeNode root) {
99+
if (root == null) {
100+
return true;
101+
}
102+
if (root.val != val) {
103+
return false;
104+
}
105+
return dfs(root.left) && dfs(root.right);
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
/**
114+
* Definition for a binary tree node.
115+
* struct TreeNode {
116+
* int val;
117+
* TreeNode *left;
118+
* TreeNode *right;
119+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
120+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
121+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
122+
* };
123+
*/
124+
class Solution {
125+
public:
126+
int val;
127+
128+
bool isUnivalTree(TreeNode* root) {
129+
val = root->val;
130+
return dfs(root);
131+
}
132+
133+
bool dfs(TreeNode* root) {
134+
if (root == nullptr) return true;
135+
if (root->val != val) return false;
136+
return dfs(root->left) && dfs(root->right);
137+
}
138+
};
139+
```
60140
141+
### **Go**
142+
143+
```go
144+
/**
145+
* Definition for a binary tree node.
146+
* type TreeNode struct {
147+
* Val int
148+
* Left *TreeNode
149+
* Right *TreeNode
150+
* }
151+
*/
152+
func isUnivalTree(root *TreeNode) bool {
153+
return dfs(root, root.Val)
154+
}
155+
156+
func dfs(root *TreeNode, val int) bool {
157+
if root == nil {
158+
return true
159+
}
160+
if root.Val != val {
161+
return false
162+
}
163+
return dfs(root.Left, val) && dfs(root.Right, val)
164+
}
61165
```
62166

63167
### **...**

‎solution/0900-0999/0965.Univalued Binary Tree/README_EN.md

+106-17
Original file line numberDiff line numberDiff line change
@@ -6,16 +6,10 @@
66

77
<p>A binary tree is <em>univalued</em> if every node in the tree has the same value.</p>
88

9-
10-
119
<p>Return <code>true</code>&nbsp;if and only if the given tree is univalued.</p>
1210

13-
14-
1511
<p>&nbsp;</p>
1612

17-
18-
1913
<p><strong>Example 1:</strong></p>
2014

2115
<img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0900-0999/0965.Univalued%20Binary%20Tree/images/unival_bst_1.png" style="width: 265px; height: 172px;" />
@@ -28,8 +22,6 @@
2822

2923
</pre>
3024

31-
32-
3325
<div>
3426

3527
<p><strong>Example 2:</strong></p>
@@ -46,37 +38,134 @@
4638

4739
</div>
4840

49-
50-
5141
<p>&nbsp;</p>
5242

53-
54-
5543
<p><strong>Note:</strong></p>
5644

57-
58-
5945
<ol>
6046
<li>The number of nodes in the given tree will be in the range <code>[1, 100]</code>.</li>
6147
<li>Each node&#39;s value will be an integer in the range <code>[0, 99]</code>.</li>
6248
</ol>
6349

64-
65-
6650
## Solutions
6751

6852
<!-- tabs:start -->
6953

7054
### **Python3**
7155

7256
```python
73-
57+
# Definition for a binary tree node.
58+
# class TreeNode:
59+
# def __init__(self, val=0, left=None, right=None):
60+
# self.val = val
61+
# self.left = left
62+
# self.right = right
63+
class Solution:
64+
def isUnivalTree(self, root: TreeNode) -> bool:
65+
def dfs(root):
66+
if root is None:
67+
return True
68+
if root.val != self.val:
69+
return False
70+
return dfs(root.left) and dfs(root.right)
71+
72+
self.val = root.val
73+
return dfs(root)
7474
```
7575

7676
### **Java**
7777

7878
```java
79+
/**
80+
* Definition for a binary tree node.
81+
* public class TreeNode {
82+
* int val;
83+
* TreeNode left;
84+
* TreeNode right;
85+
* TreeNode() {}
86+
* TreeNode(int val) { this.val = val; }
87+
* TreeNode(int val, TreeNode left, TreeNode right) {
88+
* this.val = val;
89+
* this.left = left;
90+
* this.right = right;
91+
* }
92+
* }
93+
*/
94+
class Solution {
95+
private int val;
96+
97+
public boolean isUnivalTree(TreeNode root) {
98+
val = root.val;
99+
return dfs(root);
100+
}
101+
102+
private boolean dfs(TreeNode root) {
103+
if (root == null) {
104+
return true;
105+
}
106+
if (root.val != val) {
107+
return false;
108+
}
109+
return dfs(root.left) && dfs(root.right);
110+
}
111+
}
112+
```
113+
114+
### **C++**
115+
116+
```cpp
117+
/**
118+
* Definition for a binary tree node.
119+
* struct TreeNode {
120+
* int val;
121+
* TreeNode *left;
122+
* TreeNode *right;
123+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
124+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
125+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
126+
* };
127+
*/
128+
class Solution {
129+
public:
130+
int val;
131+
132+
bool isUnivalTree(TreeNode* root) {
133+
val = root->val;
134+
return dfs(root);
135+
}
136+
137+
bool dfs(TreeNode* root) {
138+
if (root == nullptr) return true;
139+
if (root->val != val) return false;
140+
return dfs(root->left) && dfs(root->right);
141+
}
142+
};
143+
```
79144
145+
### **Go**
146+
147+
```go
148+
/**
149+
* Definition for a binary tree node.
150+
* type TreeNode struct {
151+
* Val int
152+
* Left *TreeNode
153+
* Right *TreeNode
154+
* }
155+
*/
156+
func isUnivalTree(root *TreeNode) bool {
157+
return dfs(root, root.Val)
158+
}
159+
160+
func dfs(root *TreeNode, val int) bool {
161+
if root == nil {
162+
return true
163+
}
164+
if root.Val != val {
165+
return false
166+
}
167+
return dfs(root.Left, val) && dfs(root.Right, val)
168+
}
80169
```
81170

82171
### **...**

‎solution/0900-0999/0965.Univalued Binary Tree/Solution.cpp

+14-18
Original file line numberDiff line numberDiff line change
@@ -4,27 +4,23 @@
44
* int val;
55
* TreeNode *left;
66
* TreeNode *right;
7-
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
810
* };
911
*/
1012
class Solution {
11-
private:
12-
bool isUnivalVal(TreeNode* r, int val)
13-
{
14-
if (val != r->val)
15-
return false ;
16-
17-
if (r->left && !isUnivalVal(r->left, val))
18-
return false ;
19-
if (r->right && !isUnivalVal(r->right, val))
20-
return false ;
21-
22-
return true ;
23-
}
2413
public:
14+
int val;
15+
2516
bool isUnivalTree(TreeNode* root) {
26-
if (nullptr == root)
27-
return true ;
28-
return isUnivalVal(root, root->val) ;
17+
val = root->val;
18+
return dfs(root);
19+
}
20+
21+
bool dfs(TreeNode* root) {
22+
if (root == nullptr) return true;
23+
if (root->val != val) return false;
24+
return dfs(root->left) && dfs(root->right);
2925
}
30-
} ;
26+
};

‎solution/0900-0999/0965.Univalued Binary Tree/Solution.go

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func isUnivalTree(root *TreeNode) bool {
10+
return dfs(root, root.Val)
11+
}
12+
13+
func dfs(root *TreeNode, val int) bool {
14+
if root == nil {
15+
return true
16+
}
17+
if root.Val != val {
18+
return false
19+
}
20+
return dfs(root.Left, val) && dfs(root.Right, val)
21+
}

0 commit comments

Comments
 (0)