Skip to content

Commit 318797d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0226
No.0226.Invert Binary Tree
1 parent c89e3b7 commit 318797d

File tree

3 files changed

+289
-1
lines changed

3 files changed

+289
-1
lines changed

‎solution/0200-0299/0222.Count Complete Tree Nodes/README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@
6868
我们可以先对 $root$ 的左右子树进行高度统计，分别记为 $left$ 和 $right$。
6969

7070
1. 若 $left = right$，说明左子树是一颗满二叉树，那么左子树的结点总数为 $2^{left} - 1$，加上 $root$ 结点，就是 $2^{left}$，然后递归统计右子树即可。
71-
1. 若 $left > right$，说明右子树是一个满二叉树，那么右子树的结点总数为 $2^{right} - 1$，加上 $root$ 结点，就是 $2^{right}$，然后递归统计左子树即可。
71+
1. 若 $left \gt right$，说明右子树是一个满二叉树，那么右子树的结点总数为 $2^{right} - 1$，加上 $root$ 结点，就是 $2^{right}$，然后递归统计左子树即可。
7272

7373
时间复杂度 $O(\log^2 n)$。
7474

‎solution/0200-0299/0226.Invert Binary Tree/README.md

Lines changed: 144 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,22 @@ class Solution:
8080
return root
8181
```
8282

83+
```python
84+
# Definition for a binary tree node.
85+
# class TreeNode:
86+
# def __init__(self, val=0, left=None, right=None):
87+
# self.val = val
88+
# self.left = left
89+
# self.right = right
90+
class Solution:
91+
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
92+
if root is None:
93+
return None
94+
l, r = self.invertTree(root.left), self.invertTree(root.right)
95+
root.left, root.right = r, l
96+
return root
97+
```
98+
8399
### **Java**
84100

85101
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -119,6 +135,36 @@ class Solution {
119135
}
120136
```
121137

138+
```java
139+
/**
140+
* Definition for a binary tree node.
141+
* public class TreeNode {
142+
* int val;
143+
* TreeNode left;
144+
* TreeNode right;
145+
* TreeNode() {}
146+
* TreeNode(int val) { this.val = val; }
147+
* TreeNode(int val, TreeNode left, TreeNode right) {
148+
* this.val = val;
149+
* this.left = left;
150+
* this.right = right;
151+
* }
152+
* }
153+
*/
154+
class Solution {
155+
public TreeNode invertTree(TreeNode root) {
156+
if (root == null) {
157+
return null;
158+
}
159+
TreeNode l = invertTree(root.left);
160+
TreeNode r = invertTree(root.right);
161+
root.left = r;
162+
root.right = l;
163+
return root;
164+
}
165+
}
166+
```
167+
122168
### **C++**
123169

124170
```cpp
@@ -150,6 +196,33 @@ public:
150196
};
151197
```
152198
199+
```cpp
200+
/**
201+
* Definition for a binary tree node.
202+
* struct TreeNode {
203+
* int val;
204+
* TreeNode *left;
205+
* TreeNode *right;
206+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
207+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
208+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
209+
* };
210+
*/
211+
class Solution {
212+
public:
213+
TreeNode* invertTree(TreeNode* root) {
214+
if (!root) {
215+
return root;
216+
}
217+
TreeNode* l = invertTree(root->left);
218+
TreeNode* r = invertTree(root->right);
219+
root->left = r;
220+
root->right = l;
221+
return root;
222+
}
223+
};
224+
```
225+
153226
### **Go**
154227

155228
```go
@@ -176,6 +249,25 @@ func invertTree(root *TreeNode) *TreeNode {
176249
}
177250
```
178251

252+
```go
253+
/**
254+
* Definition for a binary tree node.
255+
* type TreeNode struct {
256+
* Val int
257+
* Left *TreeNode
258+
* Right *TreeNode
259+
* }
260+
*/
261+
func invertTree(root *TreeNode) *TreeNode {
262+
if root == nil {
263+
return root
264+
}
265+
l, r := invertTree(root.Left), invertTree(root.Right)
266+
root.Left, root.Right = r, l
267+
return root
268+
}
269+
```
270+
179271
### **JavaScript**
180272

181273
```js
@@ -205,6 +297,31 @@ var invertTree = function (root) {
205297
};
206298
```
207299

300+
```js
301+
/**
302+
* Definition for a binary tree node.
303+
* function TreeNode(val, left, right) {
304+
* this.val = (val===undefined ? 0 : val)
305+
* this.left = (left===undefined ? null : left)
306+
* this.right = (right===undefined ? null : right)
307+
* }
308+
*/
309+
/**
310+
* @param {TreeNode} root
311+
* @return {TreeNode}
312+
*/
313+
var invertTree = function (root) {
314+
if (!root) {
315+
return root;
316+
}
317+
const l = invertTree(root.left);
318+
const r = invertTree(root.right);
319+
root.left = r;
320+
root.right = l;
321+
return root;
322+
};
323+
```
324+
208325
### **TypeScript**
209326

210327
```ts
@@ -236,6 +353,33 @@ function invertTree(root: TreeNode | null): TreeNode | null {
236353
}
237354
```
238355

356+
```ts
357+
/**
358+
* Definition for a binary tree node.
359+
* class TreeNode {
360+
* val: number
361+
* left: TreeNode | null
362+
* right: TreeNode | null
363+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
364+
* this.val = (val===undefined ? 0 : val)
365+
* this.left = (left===undefined ? null : left)
366+
* this.right = (right===undefined ? null : right)
367+
* }
368+
* }
369+
*/
370+
371+
function invertTree(root: TreeNode | null): TreeNode | null {
372+
if (!root) {
373+
return root;
374+
}
375+
const l = invertTree(root.left);
376+
const r = invertTree(root.right);
377+
root.left = r;
378+
root.right = l;
379+
return root;
380+
}
381+
```
382+
239383
### **...**
240384

241385
```

‎solution/0200-0299/0226.Invert Binary Tree/README_EN.md

Lines changed: 144 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,22 @@ class Solution:
6464
return root
6565
```
6666

67+
```python
68+
# Definition for a binary tree node.
69+
# class TreeNode:
70+
# def __init__(self, val=0, left=None, right=None):
71+
# self.val = val
72+
# self.left = left
73+
# self.right = right
74+
class Solution:
75+
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
76+
if root is None:
77+
return None
78+
l, r = self.invertTree(root.left), self.invertTree(root.right)
79+
root.left, root.right = r, l
80+
return root
81+
```
82+
6783
### **Java**
6884

6985
```java
@@ -101,6 +117,36 @@ class Solution {
101117
}
102118
```
103119

120+
```java
121+
/**
122+
* Definition for a binary tree node.
123+
* public class TreeNode {
124+
* int val;
125+
* TreeNode left;
126+
* TreeNode right;
127+
* TreeNode() {}
128+
* TreeNode(int val) { this.val = val; }
129+
* TreeNode(int val, TreeNode left, TreeNode right) {
130+
* this.val = val;
131+
* this.left = left;
132+
* this.right = right;
133+
* }
134+
* }
135+
*/
136+
class Solution {
137+
public TreeNode invertTree(TreeNode root) {
138+
if (root == null) {
139+
return null;
140+
}
141+
TreeNode l = invertTree(root.left);
142+
TreeNode r = invertTree(root.right);
143+
root.left = r;
144+
root.right = l;
145+
return root;
146+
}
147+
}
148+
```
149+
104150
### **C++**
105151

106152
```cpp
@@ -132,6 +178,33 @@ public:
132178
};
133179
```
134180
181+
```cpp
182+
/**
183+
* Definition for a binary tree node.
184+
* struct TreeNode {
185+
* int val;
186+
* TreeNode *left;
187+
* TreeNode *right;
188+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
189+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
190+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
191+
* };
192+
*/
193+
class Solution {
194+
public:
195+
TreeNode* invertTree(TreeNode* root) {
196+
if (!root) {
197+
return root;
198+
}
199+
TreeNode* l = invertTree(root->left);
200+
TreeNode* r = invertTree(root->right);
201+
root->left = r;
202+
root->right = l;
203+
return root;
204+
}
205+
};
206+
```
207+
135208
### **Go**
136209

137210
```go
@@ -158,6 +231,25 @@ func invertTree(root *TreeNode) *TreeNode {
158231
}
159232
```
160233

234+
```go
235+
/**
236+
* Definition for a binary tree node.
237+
* type TreeNode struct {
238+
* Val int
239+
* Left *TreeNode
240+
* Right *TreeNode
241+
* }
242+
*/
243+
func invertTree(root *TreeNode) *TreeNode {
244+
if root == nil {
245+
return root
246+
}
247+
l, r := invertTree(root.Left), invertTree(root.Right)
248+
root.Left, root.Right = r, l
249+
return root
250+
}
251+
```
252+
161253
### **JavaScript**
162254

163255
```js
@@ -187,6 +279,31 @@ var invertTree = function (root) {
187279
};
188280
```
189281

282+
```js
283+
/**
284+
* Definition for a binary tree node.
285+
* function TreeNode(val, left, right) {
286+
* this.val = (val===undefined ? 0 : val)
287+
* this.left = (left===undefined ? null : left)
288+
* this.right = (right===undefined ? null : right)
289+
* }
290+
*/
291+
/**
292+
* @param {TreeNode} root
293+
* @return {TreeNode}
294+
*/
295+
var invertTree = function (root) {
296+
if (!root) {
297+
return root;
298+
}
299+
const l = invertTree(root.left);
300+
const r = invertTree(root.right);
301+
root.left = r;
302+
root.right = l;
303+
return root;
304+
};
305+
```
306+
190307
### **TypeScript**
191308

192309
```ts
@@ -218,6 +335,33 @@ function invertTree(root: TreeNode | null): TreeNode | null {
218335
}
219336
```
220337

338+
```ts
339+
/**
340+
* Definition for a binary tree node.
341+
* class TreeNode {
342+
* val: number
343+
* left: TreeNode | null
344+
* right: TreeNode | null
345+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
346+
* this.val = (val===undefined ? 0 : val)
347+
* this.left = (left===undefined ? null : left)
348+
* this.right = (right===undefined ? null : right)
349+
* }
350+
* }
351+
*/
352+
353+
function invertTree(root: TreeNode | null): TreeNode | null {
354+
if (!root) {
355+
return root;
356+
}
357+
const l = invertTree(root.left);
358+
const r = invertTree(root.right);
359+
root.left = r;
360+
root.right = l;
361+
return root;
362+
}
363+
```
364+
221365
### **...**
222366

223367
```

0 commit comments

Comments
 (0)