algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-08 00:43:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2195 from jinbudaily/master

Browse Source 
更新 二叉树章节前两周 排版格式修复
This commit is contained in:
程序员Carl
2023-07-21 20:10:08 +08:00
committed by GitHub
parent 8c28b18fc5 25aaae38c0
commit 59f461608f
12 changed files with 372 additions and 344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
problems/0101.对称二叉树.md
View File

@ -13,9 +13,11 @@
![101. 对称二叉树](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203144607387.png) ![101. 对称二叉树](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203144607387.png)
# 思路 ## 算法公开课
《代码随想录》算法视频公开课：[同时操作两个二叉树 | LeetCode：101. 对称二叉树](https://www.bilibili.com/video/BV1ue4y1Y7Mf)，相信结合视频在看本篇题解，更有助于大家对本题的理解。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[同时操作两个二叉树 | LeetCode：101. 对称二叉树](https://www.bilibili.com/video/BV1ue4y1Y7Mf)， 相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路
**首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！** **首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！**
@ -41,7 +43,7 @@
那么我们先来看看递归法的代码应该怎么写。 那么我们先来看看递归法的代码应该怎么写。
## 递归法 ### 递归法
递归三部曲 递归三部曲
@ -159,13 +161,13 @@ public:
**所以建议大家做题的时候，一定要想清楚逻辑，每一步做什么。把题目所有情况想到位，相应的代码写出来之后，再去追求简洁代码的效果。** **所以建议大家做题的时候，一定要想清楚逻辑，每一步做什么。把题目所有情况想到位，相应的代码写出来之后，再去追求简洁代码的效果。**
## 迭代法 ### 迭代法
这道题目我们也可以使用迭代法，但要注意，这里的迭代法可不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。 这道题目我们也可以使用迭代法，但要注意，这里的迭代法可不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。
这里我们可以使用队列来比较两个树（根节点的左右子树）是否相互翻转，（**注意这不是层序遍历**） 这里我们可以使用队列来比较两个树（根节点的左右子树）是否相互翻转，（**注意这不是层序遍历**）
### 使用队列 #### 使用队列
通过队列来判断根节点的左子树和右子树的内侧和外侧是否相等，如动画所示： 通过队列来判断根节点的左子树和右子树的内侧和外侧是否相等，如动画所示：
@ -207,7 +209,7 @@ public:
}; };
``` ```
### 使用栈 #### 使用栈
细心的话，其实可以发现，这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。 细心的话，其实可以发现，这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。
@ -254,12 +256,12 @@ public:
这两道题目基本和本题是一样的，只要稍加修改就可以AC。 这两道题目基本和本题是一样的，只要稍加修改就可以AC。
* 100.相同的树 * [100.相同的树](https://leetcode.cn/problems/same-tree/)
* 572.另一个树的子树 * [572.另一个树的子树](https://leetcode.cn/problems/subtree-of-another-tree/)
# 其他语言版本 ## 其他语言版本
Java ### Java:
```Java ```Java
/** /**
@ -364,7 +366,7 @@ Java
``` ```
Python ### Python:
递归法: 递归法:
```python ```python
@ -470,7 +472,8 @@ class Solution:
return True return True
``` ```
Go ### Go:
```go ```go
/** /**
* Definition for a binary tree node. * Definition for a binary tree node.
@ -521,8 +524,7 @@ func isSymmetric(root *TreeNode) bool {
} }
``` ```
### JavaScript:
JavaScript
递归判断是否为对称二叉树： 递归判断是否为对称二叉树：
```javascript ```javascript
@ -610,7 +612,7 @@ var isSymmetric = function(root) {
}; };
``` ```
TypeScript： ### TypeScript：
> 递归法 > 递归法
@ -679,7 +681,7 @@ function isSymmetric(root: TreeNode | null): boolean {
}; };
``` ```
Swift: ### Swift:
> 递归 > 递归
```swift ```swift
@ -761,7 +763,7 @@ func isSymmetric3(_ root: TreeNode?) -> Bool {
} }
``` ```
Scala ### Scala:
> 递归： > 递归：
```scala ```scala
@ -835,7 +837,7 @@ object Solution {
} }
``` ```
## Rust ### Rust:
递归： 递归：
```rust ```rust
@ -900,3 +902,4 @@ impl Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

284
problems/0102.二叉树的层序遍历.md
View File

@ -8,21 +8,23 @@
# 二叉树层序遍历登场！ # 二叉树层序遍历登场！
《代码随想录》算法视频公开课：[讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历](https://www.bilibili.com/video/BV1GY4y1u7b2)，相信结合视频在看本篇题解，更有助于大家对本题的理解。 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历](https://www.bilibili.com/video/BV1GY4y1u7b2)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
学会二叉树的层序遍历，可以一口气打完以下十题： 学会二叉树的层序遍历，可以一口气打完以下十题：
* 102.二叉树的层序遍历 * [102.二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
* 107.二叉树的层次遍历II * [107.二叉树的层次遍历II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/)
* 199.二叉树的右视图 * [199.二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view/)
* 637.二叉树的层平均值 * [637.二叉树的层平均值](https://leetcode.cn/problems/binary-tree-right-side-view/)
* 429.N叉树的层序遍历 * [429.N叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)
* 515.在每个树行中找最大值 * [515.在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/)
* 116.填充每个节点的下一个右侧节点指针 * [116.填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
* 117.填充每个节点的下一个右侧节点指针II * [117.填充每个节点的下一个右侧节点指针II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/)
* 104.二叉树的最大深度 * [104.二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
* 111.二叉树的最小深度 * [111.二叉树的最小深度](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
@ -31,7 +33,7 @@
# 102.二叉树的层序遍历 ## 102.二叉树的层序遍历
[力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal/) [力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
@ -39,7 +41,7 @@
![102.二叉树的层序遍历](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203144842988.png) ![102.二叉树的层序遍历](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203144842988.png)
思路： ### 思路
我们之前讲过了三篇关于二叉树的深度优先遍历的文章： 我们之前讲过了三篇关于二叉树的深度优先遍历的文章：
@ -63,7 +65,7 @@
代码如下：**这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了**。 代码如下：**这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了**。
C++代码： c++代码如下：
```CPP ```CPP
class Solution { class Solution {
@ -111,7 +113,9 @@ public:
}; };
``` ```
java: ### 其他语言版本
#### Java:
```Java ```Java
// 102.二叉树的层序遍历 // 102.二叉树的层序遍历
@ -167,7 +171,7 @@ class Solution {
} }
``` ```
python3代码： #### Python:
```python ```python
@ -219,12 +223,9 @@ class Solution:
self.helper(node.left, level + 1, levels) self.helper(node.left, level + 1, levels)
self.helper(node.right, level + 1, levels) self.helper(node.right, level + 1, levels)
``` ```
#### Go:
go:
```go ```go
/** /**
@ -320,7 +321,7 @@ func levelOrder(root *TreeNode) (res [][]int) {
} }
``` ```
javascript代码： #### Javascript：
```javascript ```javascript
var levelOrder = function(root) { var levelOrder = function(root) {
@ -350,7 +351,7 @@ var levelOrder = function(root) {
``` ```
TypeScript： #### TypeScript：
```typescript ```typescript
function levelOrder(root: TreeNode | null): number[][] { function levelOrder(root: TreeNode | null): number[][] {
@ -377,7 +378,7 @@ function levelOrder(root: TreeNode | null): number[][] {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func levelOrder(_ root: TreeNode?) -> [[Int]] { func levelOrder(_ root: TreeNode?) -> [[Int]] {
@ -403,7 +404,7 @@ func levelOrder(_ root: TreeNode?) -> [[Int]] {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 102.二叉树的层序遍历 // 102.二叉树的层序遍历
@ -430,7 +431,7 @@ object Solution {
} }
``` ```
Rust: #### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
@ -466,7 +467,7 @@ impl Solution {
**此时我们就掌握了二叉树的层序遍历了，那么如下九道力扣上的题目，只需要修改模板的两三行代码（不能再多了），便可打倒！** **此时我们就掌握了二叉树的层序遍历了，那么如下九道力扣上的题目，只需要修改模板的两三行代码（不能再多了），便可打倒！**
# 107.二叉树的层次遍历 II ## 107.二叉树的层次遍历 II
[力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/) [力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/)
@ -474,7 +475,7 @@ impl Solution {
![107.二叉树的层次遍历II](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151058308.png) ![107.二叉树的层次遍历II](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151058308.png)
思路： ### 思路
相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。 相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。
@ -506,7 +507,9 @@ public:
}; };
``` ```
python代码： ### 其他语言版本
#### Python：
```python ```python
class Solution: class Solution:
@ -537,7 +540,7 @@ class Solution:
return result[::-1] return result[::-1]
``` ```
Java： #### Java：
```java ```java
// 107. 二叉树的层序遍历 II // 107. 二叉树的层序遍历 II
@ -618,12 +621,10 @@ class Solution {
return ans; return ans;
} }
}
``` ```
#### Go:
go:
```GO ```GO
/** /**
@ -662,7 +663,7 @@ func levelOrderBottom(root *TreeNode) [][]int {
} }
``` ```
javascript代码 #### Javascript:
```javascript ```javascript
var levelOrderBottom = function(root) { var levelOrderBottom = function(root) {
@ -688,7 +689,7 @@ var levelOrderBottom = function(root) {
}; };
``` ```
TypeScript: #### TypeScript:
```typescript ```typescript
function levelOrderBottom(root: TreeNode | null): number[][] { function levelOrderBottom(root: TreeNode | null): number[][] {
@ -711,7 +712,7 @@ function levelOrderBottom(root: TreeNode | null): number[][] {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func levelOrderBottom(_ root: TreeNode?) -> [[Int]] { func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
@ -737,8 +738,7 @@ func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
} }
``` ```
#### Scala:
Scala:
```scala ```scala
// 107.二叉树的层次遍历II // 107.二叉树的层次遍历II
@ -764,7 +764,10 @@ object Solution {
res.reverse.toList res.reverse.toList
} }
Rust:
```
#### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
@ -796,7 +799,7 @@ impl Solution {
} }
``` ```
# 199.二叉树的右视图 ## 199.二叉树的右视图
[力扣题目链接](https://leetcode.cn/problems/binary-tree-right-side-view/) [力扣题目链接](https://leetcode.cn/problems/binary-tree-right-side-view/)
@ -804,7 +807,7 @@ impl Solution {
![199.二叉树的右视图](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151307377.png) ![199.二叉树的右视图](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151307377.png)
思路： ### 思路
层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。 层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
@ -832,7 +835,9 @@ public:
}; };
``` ```
python代码： ### 其他语言版本
#### Python：
```python ```python
# Definition for a binary tree node. # Definition for a binary tree node.
@ -866,8 +871,7 @@ class Solution:
return right_view return right_view
``` ```
#### Java:
Java:
```java ```java
// 199.二叉树的右视图 // 199.二叉树的右视图
@ -911,7 +915,7 @@ public class N0199 {
} }
``` ```
go: #### Go:
```GO ```GO
/** /**
@ -945,8 +949,7 @@ func rightSideView(root *TreeNode) []int {
} }
``` ```
#### Javascript:
javascript代码:
```javascript ```javascript
var rightSideView = function(root) { var rightSideView = function(root) {
@ -972,7 +975,7 @@ var rightSideView = function(root) {
}; };
``` ```
TypeScript： #### TypeScript：
```typescript ```typescript
function rightSideView(root: TreeNode | null): number[] { function rightSideView(root: TreeNode | null): number[] {
@ -992,7 +995,7 @@ function rightSideView(root: TreeNode | null): number[] {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func rightSideView(_ root: TreeNode?) -> [Int] { func rightSideView(_ root: TreeNode?) -> [Int] {
@ -1017,7 +1020,7 @@ func rightSideView(_ root: TreeNode?) -> [Int] {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 199.二叉树的右视图 // 199.二叉树的右视图
@ -1043,7 +1046,7 @@ object Solution {
} }
``` ```
rust: #### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
@ -1076,7 +1079,7 @@ impl Solution {
} }
``` ```
# 637.二叉树的层平均值 ## 637.二叉树的层平均值
[力扣题目链接](https://leetcode.cn/problems/average-of-levels-in-binary-tree/) [力扣题目链接](https://leetcode.cn/problems/average-of-levels-in-binary-tree/)
@ -1084,7 +1087,7 @@ impl Solution {
![637.二叉树的层平均值](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151350500.png) ![637.二叉树的层平均值](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151350500.png)
思路: ### 思路
本题就是层序遍历的时候把一层求个总和在取一个均值。 本题就是层序遍历的时候把一层求个总和在取一个均值。
@ -1115,7 +1118,9 @@ public:
``` ```
python代码： ### 其他语言版本
#### Python：
```python ```python
class Solution: class Solution:
@ -1155,7 +1160,7 @@ class Solution:
return averages return averages
``` ```
java: #### Java:
```java ```java
// 637. 二叉树的层平均值 // 637. 二叉树的层平均值
@ -1197,7 +1202,7 @@ public class N0637 {
} }
``` ```
go: #### Go:
```GO ```GO
/** /**
@ -1235,7 +1240,7 @@ func averageOfLevels(root *TreeNode) []float64 {
} }
``` ```
javascript代码： #### Javascript：
```javascript ```javascript
var averageOfLevels = function(root) { var averageOfLevels = function(root) {
@ -1262,7 +1267,7 @@ var averageOfLevels = function(root) {
}; };
``` ```
TypeScript： #### TypeScript：
```typescript ```typescript
function averageOfLevels(root: TreeNode | null): number[] { function averageOfLevels(root: TreeNode | null): number[] {
@ -1286,7 +1291,7 @@ function averageOfLevels(root: TreeNode | null): number[] {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func averageOfLevels(_ root: TreeNode?) -> [Double] { func averageOfLevels(_ root: TreeNode?) -> [Double] {
@ -1313,7 +1318,7 @@ func averageOfLevels(_ root: TreeNode?) -> [Double] {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 637.二叉树的层平均值 // 637.二叉树的层平均值
@ -1339,7 +1344,7 @@ object Solution {
} }
``` ```
rust: #### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
@ -1372,7 +1377,7 @@ impl Solution {
} }
``` ```
# 429.N叉树的层序遍历 ## 429.N叉树的层序遍历
[力扣题目链接](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/) [力扣题目链接](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)
@ -1390,8 +1395,7 @@ impl Solution {
[5,6] [5,6]
] ]
### 思路
思路:
这道题依旧是模板题，只不过一个节点有多个孩子了 这道题依旧是模板题，只不过一个节点有多个孩子了
@ -1423,7 +1427,9 @@ public:
}; };
``` ```
python代码： ### 其他语言版本
#### Python：
```python ```python
""" """
@ -1475,7 +1481,7 @@ class Solution:
return result return result
``` ```
java: #### Java:
```java ```java
// 429. N 叉树的层序遍历 // 429. N 叉树的层序遍历
@ -1535,8 +1541,7 @@ public class N0429 {
} }
``` ```
#### Go:
go:
```GO ```GO
/** /**
@ -1567,7 +1572,7 @@ func levelOrder(root *Node) [][]int {
} }
``` ```
JavaScript代码： #### JavaScript：
```JavaScript ```JavaScript
var levelOrder = function(root) { var levelOrder = function(root) {
@ -1596,7 +1601,7 @@ var levelOrder = function(root) {
}; };
``` ```
TypeScript: #### TypeScript:
```typescript ```typescript
function levelOrder(root: Node | null): number[][] { function levelOrder(root: Node | null): number[][] {
@ -1618,7 +1623,7 @@ function levelOrder(root: Node | null): number[][] {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func levelOrder(_ root: Node?) -> [[Int]] { func levelOrder(_ root: Node?) -> [[Int]] {
@ -1643,7 +1648,7 @@ func levelOrder(_ root: Node?) -> [[Int]] {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 429.N叉树的层序遍历 // 429.N叉树的层序遍历
@ -1672,7 +1677,7 @@ object Solution {
} }
``` ```
rust: #### Rust:
```rust ```rust
pub struct Solution; pub struct Solution;
@ -1720,7 +1725,7 @@ impl Solution {
} }
``` ```
# 515.在每个树行中找最大值 ## 515.在每个树行中找最大值
[力扣题目链接](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/) [力扣题目链接](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/)
@ -1728,7 +1733,7 @@ impl Solution {
![515.在每个树行中找最大值](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151532153.png) ![515.在每个树行中找最大值](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151532153.png)
思路： ### 思路
层序遍历，取每一层的最大值 层序遍历，取每一层的最大值
@ -1758,7 +1763,9 @@ public:
}; };
``` ```
python代码： ### 其他语言版本
#### Python：
```python ```python
# Definition for a binary tree node. # Definition for a binary tree node.
@ -1794,7 +1801,7 @@ class Solution:
return result return result
``` ```
java代码： #### Java：
```java ```java
class Solution { class Solution {
@ -1820,7 +1827,7 @@ class Solution {
} }
``` ```
go: #### Go:
```GO ```GO
/** /**
@ -1864,7 +1871,7 @@ func max(x, y int) int {
} }
``` ```
javascript代码： #### Javascript：
```javascript ```javascript
var largestValues = function(root) { var largestValues = function(root) {
@ -1890,7 +1897,7 @@ var largestValues = function(root) {
}; };
``` ```
TypeScript: #### TypeScript:
```typescript ```typescript
function largestValues(root: TreeNode | null): number[] { function largestValues(root: TreeNode | null): number[] {
@ -1916,7 +1923,7 @@ function largestValues(root: TreeNode | null): number[] {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func largestValues(_ root: TreeNode?) -> [Int] { func largestValues(_ root: TreeNode?) -> [Int] {
@ -1943,7 +1950,7 @@ func largestValues(_ root: TreeNode?) -> [Int] {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 515.在每个树行中找最大值 // 515.在每个树行中找最大值
@ -1970,7 +1977,7 @@ object Solution {
} }
``` ```
rust: #### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
@ -2002,7 +2009,7 @@ impl Solution {
} }
``` ```
# 116.填充每个节点的下一个右侧节点指针 ## 116.填充每个节点的下一个右侧节点指针
[力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/) [力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
@ -2024,7 +2031,7 @@ struct Node {
![116.填充每个节点的下一个右侧节点指针](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203152044855.jpg) ![116.填充每个节点的下一个右侧节点指针](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203152044855.jpg)
思路: ### 思路
本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了 本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了
@ -2063,7 +2070,9 @@ public:
}; };
``` ```
java代码： ### 其他语言版本
#### Java：
```java ```java
class Solution { class Solution {
@ -2093,7 +2102,7 @@ class Solution {
} }
``` ```
python代码： #### Python：
```python ```python
""" """
@ -2133,7 +2142,7 @@ class Solution:
return root return root
``` ```
go: #### Go:
```GO ```GO
/** /**
@ -2173,7 +2182,7 @@ func connect(root *Node) *Node {
``` ```
JavaScript: #### JavaScript:
```javascript ```javascript
/** /**
@ -2209,7 +2218,7 @@ var connect = function(root) {
``` ```
TypeScript: #### TypeScript:
```typescript ```typescript
function connect(root: Node | null): Node | null { function connect(root: Node | null): Node | null {
@ -2234,7 +2243,7 @@ function connect(root: Node | null): Node | null {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func connect(_ root: Node?) -> Node? { func connect(_ root: Node?) -> Node? {
@ -2266,7 +2275,7 @@ func connect(_ root: Node?) -> Node? {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 116.填充每个节点的下一个右侧节点指针 // 116.填充每个节点的下一个右侧节点指针
@ -2297,11 +2306,11 @@ object Solution {
} }
``` ```
# 117.填充每个节点的下一个右侧节点指针II ## 117.填充每个节点的下一个右侧节点指针II
[力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/) [力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/)
思路： ### 思路
这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道 这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道
@ -2339,7 +2348,9 @@ public:
}; };
``` ```
Java 代码： ### 其他语言版本
#### Java：
```java ```java
// 二叉树之层次遍历 // 二叉树之层次遍历
@ -2377,7 +2388,7 @@ class Solution {
} }
``` ```
python代码： #### Python：
```python ```python
# 层序遍历解法 # 层序遍历解法
@ -2420,7 +2431,7 @@ class Solution:
``` ```
go: #### Go:
```GO ```GO
/** /**
@ -2459,7 +2470,7 @@ func connect(root *Node) *Node {
} }
``` ```
JavaScript: #### JavaScript:
```javascript ```javascript
/** /**
@ -2494,7 +2505,7 @@ var connect = function(root) {
}; };
``` ```
TypeScript: #### TypeScript:
```typescript ```typescript
function connect(root: Node | null): Node | null { function connect(root: Node | null): Node | null {
@ -2519,7 +2530,7 @@ function connect(root: Node | null): Node | null {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func connect(_ root: Node?) -> Node? { func connect(_ root: Node?) -> Node? {
@ -2551,7 +2562,7 @@ func connect(_ root: Node?) -> Node? {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 117.填充每个节点的下一个右侧节点指针II // 117.填充每个节点的下一个右侧节点指针II
@ -2582,7 +2593,7 @@ object Solution {
} }
``` ```
# 104.二叉树的最大深度 ## 104.二叉树的最大深度
[力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/) [力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
@ -2600,7 +2611,7 @@ object Solution {
返回它的最大深度 3 。 返回它的最大深度 3 。
思路： ### 思路
使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。 使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
@ -2635,7 +2646,9 @@ public:
}; };
``` ```
Java： ### 其他语言版本
#### Java：
```Java ```Java
class Solution { class Solution {
@ -2661,7 +2674,7 @@ class Solution {
} }
``` ```
Python： #### Python：
```python 3 ```python 3
# Definition for a binary tree node. # Definition for a binary tree node.
@ -2691,7 +2704,7 @@ class Solution:
``` ```
Go： #### Go：
```go ```go
/** /**
@ -2726,7 +2739,7 @@ func maxDepth(root *TreeNode) int {
} }
``` ```
JavaScript： #### JavaScript：
```javascript ```javascript
/** /**
@ -2759,7 +2772,7 @@ var maxDepth = function(root) {
}; };
``` ```
TypeScript: #### TypeScript:
```typescript ```typescript
function maxDepth(root: TreeNode | null): number { function maxDepth(root: TreeNode | null): number {
@ -2779,7 +2792,7 @@ function maxDepth(root: TreeNode | null): number {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func maxDepth(_ root: TreeNode?) -> Int { func maxDepth(_ root: TreeNode?) -> Int {
@ -2804,7 +2817,7 @@ func maxDepth(_ root: TreeNode?) -> Int {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 104.二叉树的最大深度 // 104.二叉树的最大深度
@ -2829,7 +2842,7 @@ object Solution {
} }
``` ```
rust: #### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
@ -2859,10 +2872,12 @@ impl Solution {
} }
``` ```
# 111.二叉树的最小深度 ## 111.二叉树的最小深度
[力扣题目链接](https://leetcode.cn/problems/minimum-depth-of-binary-tree/) [力扣题目链接](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
### 思路
相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。 相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。
**需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点** **需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点**
@ -2895,7 +2910,9 @@ public:
}; };
``` ```
Java： ### 其他语言版本
#### Java：
```java ```java
class Solution { class Solution {
@ -2925,9 +2942,7 @@ class Solution {
} }
``` ```
#### Python：
Python 3：
```python 3 ```python 3
# Definition for a binary tree node. # Definition for a binary tree node.
@ -2960,7 +2975,7 @@ class Solution:
return depth return depth
``` ```
Go： #### Go：
```go ```go
/** /**
@ -2999,7 +3014,7 @@ func minDepth(root *TreeNode) int {
} }
``` ```
JavaScript： #### JavaScript：
```javascript ```javascript
/** /**
@ -3035,7 +3050,7 @@ var minDepth = function(root) {
}; };
``` ```
TypeScript: #### TypeScript:
```typescript ```typescript
function minDepth(root: TreeNode | null): number { function minDepth(root: TreeNode | null): number {
@ -3056,7 +3071,7 @@ function minDepth(root: TreeNode | null): number {
}; };
``` ```
Swift： #### Swift：
```swift ```swift
func minDepth(_ root: TreeNode?) -> Int { func minDepth(_ root: TreeNode?) -> Int {
@ -3082,7 +3097,7 @@ func minDepth(_ root: TreeNode?) -> Int {
} }
``` ```
Scala: #### Scala:
```scala ```scala
// 111.二叉树的最小深度 // 111.二叉树的最小深度
@ -3108,7 +3123,7 @@ object Solution {
} }
``` ```
rust: #### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
@ -3141,28 +3156,27 @@ impl Solution {
} }
``` ```
# 总结 ## 总结
二叉树的层序遍历，**就是图论中的广度优先搜索在二叉树中的应用**，需要借助队列来实现（此时又发现队列的一个应用了）。 二叉树的层序遍历，**就是图论中的广度优先搜索在二叉树中的应用**，需要借助队列来实现（此时又发现队列的一个应用了）。
来吧，一口气打十个： 来吧，一口气打十个：
* 102.二叉树的层序遍历 * [102.二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
* 107.二叉树的层次遍历II * [107.二叉树的层次遍历II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/)
* 199.二叉树的右视图 * [199.二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view/)
* 637.二叉树的层平均值 * [637.二叉树的层平均值](https://leetcode.cn/problems/binary-tree-right-side-view/)
* 429.N叉树的层序遍历 * [429.N叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)
* 515.在每个树行中找最大值 * [515.在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/)
* 116.填充每个节点的下一个右侧节点指针 * [116.填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
* 117.填充每个节点的下一个右侧节点指针II * [117.填充每个节点的下一个右侧节点指针II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/)
* 104.二叉树的最大深度 * [104.二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
* 111.二叉树的最小深度 * [111.二叉树的最小深度](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
**致敬叶师傅！** **致敬叶师傅！**
<p align="center"> <p align="center">
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

83
problems/0104.二叉树的最大深度.md
View File

@ -5,6 +5,7 @@
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
# 104.二叉树的最大深度 # 104.二叉树的最大深度
[力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/) [力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
@ -23,17 +24,19 @@
返回它的最大深度 3 。 返回它的最大深度 3 。
# 思路 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[二叉树的高度和深度有啥区别？究竟用什么遍历顺序？很多录友搞不懂 | 104.二叉树的最大深度](https://www.bilibili.com/video/BV1Gd4y1V75u)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路
看完本篇可以一起做了如下两道题目： 看完本篇可以一起做了如下两道题目：
* 104.二叉树的最大深度 * [104.二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
* 559.n叉树的最大深度 * [559.n叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/)
《代码随想录》算法视频公开课：[二叉树的高度和深度有啥区别？究竟用什么遍历顺序？很多录友搞不懂 | 104.二叉树的最大深度](https://www.bilibili.com/video/BV1Gd4y1V75u)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
## 递归法 ### 递归法
本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。 本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。
@ -164,7 +167,7 @@ public:
}; };
``` ```
## 迭代法 ### 迭代法
使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。 使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
@ -202,10 +205,11 @@ public:
}; };
``` ```
那么我们可以顺便解决一下n叉树的最大深度问题 那么我们可以顺便解决一下n叉树的最大深度问题
# 559.n叉树的最大深度 ## 相关题目推荐
### 559.n叉树的最大深度
[力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/) [力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/)
@ -219,11 +223,11 @@ public:
我们应返回其最大深度，3。 我们应返回其最大深度，3。
思路： ### 思路
依然可以提供递归法和迭代法，来解决这个问题，思路是和二叉树思路一样的，直接给出代码如下： 依然可以提供递归法和迭代法，来解决这个问题，思路是和二叉树思路一样的，直接给出代码如下：
## 递归法 #### 递归法
c++代码： c++代码：
@ -240,7 +244,7 @@ public:
} }
}; };
``` ```
## 迭代法 #### 迭代法
依然是层序遍历，代码如下： 依然是层序遍历，代码如下：
@ -267,11 +271,11 @@ public:
}; };
``` ```
# 其他语言版本 ## 其他语言版本
## java ### Java:
### 104.二叉树的最大深度 104.二叉树的最大深度
```java ```java
class solution { class solution {
@ -344,7 +348,8 @@ class solution {
} }
``` ```
### 559.n叉树的最大深度 559.n叉树的最大深度
```java ```java
class Solution { class Solution {
/*递归法，后序遍历求root节点的高度*/ /*递归法，后序遍历求root节点的高度*/
@ -391,9 +396,9 @@ class solution {
} }
``` ```
## python ### Python :
### 104.二叉树的最大深度 104.二叉树的最大深度
递归法： 递归法：
```python ```python
@ -448,7 +453,7 @@ class Solution:
``` ```
### 559.n叉树的最大深度 559.n叉树的最大深度
递归法： 递归法：
```python ```python
@ -522,9 +527,10 @@ class Solution:
return max_depth return max_depth
``` ```
### Go:
104.二叉树的最大深度
## go
### 104.二叉树的最大深度
```go ```go
/** /**
* definition for a binary tree node. * definition for a binary tree node.
@ -574,7 +580,7 @@ func maxdepth(root *treenode) int {
``` ```
### 559. n叉树的最大深度 559. n叉树的最大深度
```go ```go
func maxDepth(root *Node) int { func maxDepth(root *Node) int {
@ -598,9 +604,9 @@ func maxDepth(root *Node) int {
} }
``` ```
## javascript ### Javascript :
### 104.二叉树的最大深度 104.二叉树的最大深度
```javascript ```javascript
var maxdepth = function(root) { var maxdepth = function(root) {
@ -649,7 +655,7 @@ var maxDepth = function(root) {
}; };
``` ```
### 559.n叉树的最大深度 559.n叉树的最大深度
N叉树的最大深度 递归写法 N叉树的最大深度 递归写法
```js ```js
@ -683,9 +689,9 @@ var maxDepth = function(root) {
}; };
``` ```
## TypeScript ### TypeScript:
### 104.二叉树的最大深度 104.二叉树的最大深度
```typescript ```typescript
// 后续遍历（自下而上） // 后续遍历（自下而上）
@ -728,7 +734,7 @@ function maxDepth(root: TreeNode | null): number {
}; };
``` ```
### 559.n叉树的最大深度 559.n叉树的最大深度
```typescript ```typescript
// 后续遍历（自下而上） // 后续遍历（自下而上）
@ -756,9 +762,9 @@ function maxDepth(root: TreeNode | null): number {
``` ```
## C ### C:
### 104.二叉树的最大深度 104.二叉树的最大深度
二叉树最大深度递归 二叉树最大深度递归
```c ```c
@ -814,9 +820,9 @@ int maxDepth(struct TreeNode* root){
} }
``` ```
## Swift ### Swift:
### 104.二叉树的最大深度 104.二叉树的最大深度
```swift ```swift
// 递归 - 后序 // 递归 - 后序
@ -856,7 +862,7 @@ func maxDepth(_ root: TreeNode?) -> Int {
} }
``` ```
### 559.n叉树的最大深度 559.n叉树的最大深度
```swift ```swift
// 递归 // 递归
@ -893,9 +899,10 @@ func maxDepth1(_ root: Node?) -> Int {
} }
``` ```
## Scala ### Scala:
104.二叉树的最大深度
### 104.二叉树的最大深度
递归法: 递归法:
```scala ```scala
object Solution { object Solution {
@ -934,7 +941,7 @@ object Solution {
} }
``` ```
### 559.n叉树的最大深度 559.n叉树的最大深度
递归法: 递归法:
```scala ```scala
@ -972,8 +979,8 @@ object Solution {
} }
``` ```
## rust ### Rust:
### 0104.二叉树的最大深度 0104.二叉树的最大深度
递归： 递归：
```rust ```rust

18
problems/0110.平衡二叉树.md
View File

@ -33,8 +33,9 @@
返回 false 。 返回 false 。
## 算法公开课
**《代码随想录》算法视频公开课：[后序遍历求高度，高度判断是否平衡 | LeetCode：110.平衡二叉树](https://www.bilibili.com/video/BV1Ug411S7my)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[后序遍历求高度，高度判断是否平衡 | LeetCode：110.平衡二叉树](https://www.bilibili.com/video/BV1Ug411S7my)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 题外话 ## 题外话
@ -357,7 +358,7 @@ public:
## 其他语言版本 ## 其他语言版本
### Java ### Java:
```Java ```Java
class Solution { class Solution {
@ -498,7 +499,7 @@ class Solution {
} }
``` ```
### Python ### Python:
递归法： 递归法：
@ -620,7 +621,7 @@ class Solution:
height_map[real_node] = 1 + max(left, right) height_map[real_node] = 1 + max(left, right)
return True return True
``` ```
### Go ### Go:
```Go ```Go
func isBalanced(root *TreeNode) bool { func isBalanced(root *TreeNode) bool {
@ -652,7 +653,7 @@ func max(a, b int) int {
} }
``` ```
### JavaScript ### JavaScript:
递归法： 递归法：
@ -723,7 +724,7 @@ var isBalanced = function (root) {
}; };
``` ```
### TypeScript ### TypeScript:
```typescript ```typescript
// 递归法 // 递归法
@ -741,7 +742,7 @@ function isBalanced(root: TreeNode | null): boolean {
}; };
``` ```
### C ### C:
递归法： 递归法：
@ -876,7 +877,7 @@ func getHeight(_ root: TreeNode?) -> Int {
} }
``` ```
### rust ### Rust:
递归 递归
@ -912,3 +913,4 @@ impl Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

31
problems/0111.二叉树的最小深度.md
View File

@ -26,9 +26,11 @@
返回它的最小深度 2. 返回它的最小深度 2.
# 思路 ## 算法公开课
《代码随想录》算法视频公开课：[看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度](https://www.bilibili.com/video/BV1QD4y1B7e2)，相信结合视频在看本篇题解，更有助于大家对本题的理解。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度](https://www.bilibili.com/video/BV1QD4y1B7e2)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路
看完了这篇[104.二叉树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)，再来看看如何求最小深度。 看完了这篇[104.二叉树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)，再来看看如何求最小深度。
@ -52,7 +54,7 @@
什么是叶子节点，左右孩子都为空的节点才是叶子节点！ 什么是叶子节点，左右孩子都为空的节点才是叶子节点！
## 递归法 ### 递归法
来来来，一起递归三部曲： 来来来，一起递归三部曲：
@ -199,7 +201,7 @@ public:
}; };
``` ```
## 迭代法 ### 迭代法
相对于[104.二叉树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)，本题还可以使用层序遍历的方式来解决，思路是一样的。 相对于[104.二叉树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)，本题还可以使用层序遍历的方式来解决，思路是一样的。
@ -237,10 +239,10 @@ public:
``` ```
# 其他语言版本 ## 其他语言版本
## Java ### Java:
```Java ```Java
class Solution { class Solution {
@ -300,7 +302,7 @@ class Solution {
} }
``` ```
## Python ### Python :
递归法（版本一） 递归法（版本一）
@ -400,9 +402,7 @@ class Solution:
return depth return depth
``` ```
### Go:
## Go
```go ```go
/** /**
@ -463,7 +463,7 @@ func minDepth(root *TreeNode) int {
``` ```
## JavaScript ### JavaScript:
递归法： 递归法：
@ -509,7 +509,7 @@ var minDepth = function(root) {
}; };
``` ```
## TypeScript ### TypeScript:
> 递归法 > 递归法
@ -547,7 +547,7 @@ function minDepth(root: TreeNode | null): number {
}; };
``` ```
## Swift ### Swift:
> 递归 > 递归
```Swift ```Swift
@ -594,7 +594,7 @@ func minDepth(_ root: TreeNode?) -> Int {
``` ```
## Scala ### Scala:
递归法: 递归法:
```scala ```scala
@ -633,7 +633,8 @@ object Solution {
} }
``` ```
rust: ### Rust:
```rust ```rust
impl Solution { impl Solution {
// 递归 // 递归

41
problems/0222.完全二叉树的节点个数.md
View File

@ -29,14 +29,17 @@
* 0 <= Node.val <= 5 * 10^4 * 0 <= Node.val <= 5 * 10^4
* 题目数据保证输入的树是 完全二叉树 * 题目数据保证输入的树是 完全二叉树
## 算法公开课
# 思路 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[要理解普通二叉树和完全二叉树的区别！ | LeetCode：222.完全二叉树节点的数量](https://www.bilibili.com/video/BV1eW4y1B7pD)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路
《代码随想录》算法视频公开课：[要理解普通二叉树和完全二叉树的区别！ | LeetCode：222.完全二叉树节点的数量](https://www.bilibili.com/video/BV1eW4y1B7pD)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
本篇给出按照普通二叉树的求法以及利用完全二叉树性质的求法。 本篇给出按照普通二叉树的求法以及利用完全二叉树性质的求法。
## 普通二叉树 ### 普通二叉树
首先按照普通二叉树的逻辑来求。 首先按照普通二叉树的逻辑来求。
@ -44,7 +47,7 @@
递归遍历的顺序依然是后序（左右中）。 递归遍历的顺序依然是后序（左右中）。
### 递归 #### 递归
如果对求二叉树深度还不熟悉的话，看这篇：[二叉树：看看这些树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)。 如果对求二叉树深度还不熟悉的话，看这篇：[二叉树：看看这些树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)。
@ -112,7 +115,7 @@ public:
**网上基本都是这个精简的代码版本，其实不建议大家照着这个来写，代码确实精简，但隐藏了一些内容，连遍历的顺序都看不出来，所以初学者建议学习版本一的代码，稳稳的打基础**。 **网上基本都是这个精简的代码版本，其实不建议大家照着这个来写，代码确实精简，但隐藏了一些内容，连遍历的顺序都看不出来，所以初学者建议学习版本一的代码，稳稳的打基础**。
### 迭代法 #### 迭代
如果对求二叉树层序遍历还不熟悉的话，看这篇：[二叉树：层序遍历登场！](https://programmercarl.com/0102.二叉树的层序遍历.html)。 如果对求二叉树层序遍历还不熟悉的话，看这篇：[二叉树：层序遍历登场！](https://programmercarl.com/0102.二叉树的层序遍历.html)。
@ -142,7 +145,7 @@ public:
* 时间复杂度：O(n) * 时间复杂度：O(n)
* 空间复杂度：O(n) * 空间复杂度：O(n)
## 完全二叉树 ### 完全二叉树
以上方法都是按照普通二叉树来做的，对于完全二叉树特性不了解的同学可以看这篇 [关于二叉树，你该了解这些！](https://programmercarl.com/二叉树理论基础.html)，这篇详细介绍了各种二叉树的特性。 以上方法都是按照普通二叉树来做的，对于完全二叉树特性不了解的同学可以看这篇 [关于二叉树，你该了解这些！](https://programmercarl.com/二叉树理论基础.html)，这篇详细介绍了各种二叉树的特性。
@ -249,9 +252,9 @@ public:
* 时间复杂度：O(log n × log n) * 时间复杂度：O(log n × log n)
* 空间复杂度：O(log n) * 空间复杂度：O(log n)
# 其他语言版本 ## 其他语言版本
## Java ### Java:
```java ```java
class Solution { class Solution {
// 通用递归解法 // 通用递归解法
@ -312,7 +315,7 @@ class Solution {
} }
``` ```
## Python ### Python:
递归法： 递归法：
```python ```python
@ -408,7 +411,7 @@ class Solution: # 利用完全二叉树特性
return 1+self.countNodes(root.left)+self.countNodes(root.right) return 1+self.countNodes(root.left)+self.countNodes(root.right)
``` ```
## Go ### Go:
递归版本 递归版本
@ -488,9 +491,7 @@ func countNodes(root *TreeNode) int {
} }
``` ```
### JavaScript:
## JavaScript:
递归版本 递归版本
```javascript ```javascript
@ -559,7 +560,7 @@ var countNodes = function(root) {
}; };
``` ```
## TypeScrpt: ### TypeScrpt:
> 递归法 > 递归法
@ -614,7 +615,7 @@ function countNodes(root: TreeNode | null): number {
}; };
``` ```
## C: ### C:
递归法 递归法
```c ```c
@ -690,7 +691,7 @@ int countNodes(struct TreeNode* root){
} }
``` ```
## Swift: ### Swift:
> 递归 > 递归
```swift ```swift
@ -758,7 +759,7 @@ func countNodes(_ root: TreeNode?) -> Int {
} }
``` ```
## Scala ### Scala:
递归: 递归:
```scala ```scala
@ -821,9 +822,9 @@ object Solution {
} }
``` ```
rust: ### Rust:
// 递归 递归
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;
use std::rc::Rc; use std::rc::Rc;
@ -838,7 +839,7 @@ impl Solution {
} }
``` ```
// 迭代 迭代
```rust ```rust
use std::rc::Rc; use std::rc::Rc;
use std::cell::RefCell; use std::cell::RefCell;

33
problems/0226.翻转二叉树.md
View File

@ -16,7 +16,11 @@
这道题目背后有一个让程序员心酸的故事，听说 Homebrew的作者Max Howell，就是因为没在白板上写出翻转二叉树，最后被Google拒绝了。（真假不做判断，权当一个乐子哈） 这道题目背后有一个让程序员心酸的故事，听说 Homebrew的作者Max Howell，就是因为没在白板上写出翻转二叉树，最后被Google拒绝了。（真假不做判断，权当一个乐子哈）
# 题外话 ## 算法公开课
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树](https://www.bilibili.com/video/BV1sP4y1f7q7)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 题外话
这道题目是非常经典的题目，也是比较简单的题目（至少一看就会）。 这道题目是非常经典的题目，也是比较简单的题目（至少一看就会）。
@ -24,9 +28,7 @@
如果做过这道题的同学也建议认真看完，相信一定有所收获！ 如果做过这道题的同学也建议认真看完，相信一定有所收获！
# 思路 ## 思路
《代码随想录》算法视频公开课：[听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树](https://www.bilibili.com/video/BV1sP4y1f7q7)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
我们之前介绍的都是各种方式遍历二叉树，这次要翻转了，感觉还是有点懵逼。 我们之前介绍的都是各种方式遍历二叉树，这次要翻转了，感觉还是有点懵逼。
@ -49,7 +51,7 @@
那么层序遍历可以不可以呢？**依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！** 那么层序遍历可以不可以呢？**依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！**
## 递归法 ### 递归法
对于二叉树的递归法的前中后序遍历，已经在[二叉树：前中后序递归遍历](https://programmercarl.com/二叉树的递归遍历.html)详细讲解了。 对于二叉树的递归法的前中后序遍历，已经在[二叉树：前中后序递归遍历](https://programmercarl.com/二叉树的递归遍历.html)详细讲解了。
@ -102,9 +104,9 @@ public:
}; };
``` ```
## 迭代法 ### 迭代法
### 深度优先遍历 #### 深度优先遍历
[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本题可以很轻松的写出如下迭代法的代码： [二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本题可以很轻松的写出如下迭代法的代码：
@ -163,7 +165,7 @@ public:
如果上面这个代码看不懂，回顾一下文章[二叉树：前中后序迭代方式的统一写法](https://programmercarl.com/二叉树的统一迭代法.html)。 如果上面这个代码看不懂，回顾一下文章[二叉树：前中后序迭代方式的统一写法](https://programmercarl.com/二叉树的统一迭代法.html)。
### 广度优先遍历 #### 广度优先遍历
也就是层序遍历，层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下： 也就是层序遍历，层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下：
@ -259,7 +261,7 @@ public:
## 其他语言版本 ## 其他语言版本
### Java ### Java:
```Java ```Java
//DFS递归 //DFS递归
class Solution { class Solution {
@ -310,7 +312,7 @@ class Solution {
} }
``` ```
### Python ### Python:
递归法：前序遍历： 递归法：前序遍历：
```python ```python
@ -466,7 +468,7 @@ class Solution:
``` ```
### Go ### Go:
递归版本的前序遍历 递归版本的前序遍历
```Go ```Go
@ -575,7 +577,7 @@ func invertTree(root *TreeNode) *TreeNode {
} }
``` ```
### JavaScript ### JavaScript:
使用递归版本的前序遍历 使用递归版本的前序遍历
```javascript ```javascript
@ -783,7 +785,7 @@ function invertTree(root: TreeNode | null): TreeNode | null {
}; };
``` ```
### C ### C:
递归法 递归法
```c ```c
@ -961,7 +963,7 @@ object Solution {
} }
``` ```
### rust ### Rust:
```rust ```rust
impl Solution { impl Solution {
@ -991,7 +993,7 @@ impl Solution {
} }
``` ```
### C# ### C#:
```csharp ```csharp
//递归 //递归
@ -1042,3 +1044,4 @@ public class Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

43
problems/0257.二叉树的所有路径.md
View File

@ -18,9 +18,11 @@
示例: 示例:
![257.二叉树的所有路径1](https://code-thinking-1253855093.file.myqcloud.com/pics/2021020415161576.png) ![257.二叉树的所有路径1](https://code-thinking-1253855093.file.myqcloud.com/pics/2021020415161576.png)
# 思路 ## 算法公开课
**《代码随想录》算法视频公开课：[递归中带着回溯，你感受到了没？| LeetCode：257. 二叉树的所有路径](https://www.bilibili.com/video/BV1ZG411G7Dh)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：：[递归中带着回溯，你感受到了没？| LeetCode：257. 二叉树的所有路径](https://www.bilibili.com/video/BV1ZG411G7Dh)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路
这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。 这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。
@ -32,7 +34,7 @@
我们先使用递归的方式，来做前序遍历。**要知道递归和回溯就是一家的，本题也需要回溯。** 我们先使用递归的方式，来做前序遍历。**要知道递归和回溯就是一家的，本题也需要回溯。**
## 递归 ### 递归
1. 递归函数参数以及返回值 1. 递归函数参数以及返回值
@ -305,7 +307,7 @@ public:
**综合以上，第二种递归的代码虽然精简但把很多重要的点隐藏在了代码细节里，第一种递归写法虽然代码多一些，但是把每一个逻辑处理都完整的展现出来了。** **综合以上，第二种递归的代码虽然精简但把很多重要的点隐藏在了代码细节里，第一种递归写法虽然代码多一些，但是把每一个逻辑处理都完整的展现出来了。**
## 拓展 ### 拓展
这里讲解本题解的写法逻辑以及一些更具体的细节，下面的讲解中，涉及到C++语法特性，如果不是C++的录友，就可以不看了，避免越看越晕。 这里讲解本题解的写法逻辑以及一些更具体的细节，下面的讲解中，涉及到C++语法特性，如果不是C++的录友，就可以不看了，避免越看越晕。
@ -328,7 +330,7 @@ public:
所以，第一个代码版本中，我才使用 vector 类型的path，这样方便给大家演示代码中回溯的操作。 vector类型的path，不管 每次 路径收集的数字是几位数，总之一定是int，所以就一次 pop_back就可以。 所以，第一个代码版本中，我才使用 vector 类型的path，这样方便给大家演示代码中回溯的操作。 vector类型的path，不管 每次 路径收集的数字是几位数，总之一定是int，所以就一次 pop_back就可以。
## 迭代法 ### 迭代法
至于非递归的方式，我们可以依然可以使用前序遍历的迭代方式来模拟遍历路径的过程，对该迭代方式不了解的同学，可以看文章[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)和[二叉树：前中后序迭代方式统一写法](https://programmercarl.com/二叉树的统一迭代法.html)。 至于非递归的方式，我们可以依然可以使用前序遍历的迭代方式来模拟遍历路径的过程，对该迭代方式不了解的同学，可以看文章[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)和[二叉树：前中后序迭代方式统一写法](https://programmercarl.com/二叉树的统一迭代法.html)。
@ -368,7 +370,7 @@ public:
``` ```
当然，使用java的同学，可以直接定义一个成员变量为object的栈`Stack<Object> stack = new Stack<>();`，这样就不用定义两个栈了，都放到一个栈里就可以了。 当然，使用java的同学，可以直接定义一个成员变量为object的栈`Stack<Object> stack = new Stack<>();`，这样就不用定义两个栈了，都放到一个栈里就可以了。
# 总结 ## 总结
**本文我们开始初步涉及到了回溯，很多同学过了这道题目，可能都不知道自己其实使用了回溯，回溯和递归都是相伴相生的。** **本文我们开始初步涉及到了回溯，很多同学过了这道题目，可能都不知道自己其实使用了回溯，回溯和递归都是相伴相生的。**
@ -380,13 +382,9 @@ public:
对于本题充分了解递归与回溯的过程之后，有精力的同学可以再去实现迭代法。 对于本题充分了解递归与回溯的过程之后，有精力的同学可以再去实现迭代法。
## 其他语言版本
### Java：
# 其他语言版本
## Java：
```Java ```Java
//解法一 //解法一
@ -492,9 +490,9 @@ class Solution {
} }
``` ```
--- ---
## Python: ### Python:
递归法+回溯 递归法+回溯
```Python ```Python
# Definition for a binary tree node. # Definition for a binary tree node.
@ -552,7 +550,7 @@ class Solution:
self.traversal(cur.right, path[:], result) self.traversal(cur.right, path[:], result)
``` ```
递归法+隐形回溯（版本二） 递归法+隐形回溯（版本二）
```Python ```Python
# Definition for a binary tree node. # Definition for a binary tree node.
@ -610,7 +608,7 @@ class Solution:
--- ---
## Go： ### Go：
递归法： 递归法：
@ -672,7 +670,7 @@ func binaryTreePaths(root *TreeNode) []string {
``` ```
--- ---
## JavaScript: ### JavaScript:
递归法： 递归法：
@ -725,7 +723,7 @@ var binaryTreePaths = function(root) {
}; };
``` ```
## TypeScript： ### TypeScript：
> 递归法 > 递归法
@ -779,7 +777,7 @@ function binaryTreePaths(root: TreeNode | null): string[] {
}; };
``` ```
## Swift: ### Swift:
> 递归/回溯 > 递归/回溯
```swift ```swift
@ -846,7 +844,7 @@ func binaryTreePaths(_ root: TreeNode?) -> [String] {
} }
``` ```
## Scala: ### Scala:
递归: 递归:
```scala ```scala
@ -876,7 +874,7 @@ object Solution {
} }
``` ```
rust: ### Rust:
```rust ```rust
// 递归 // 递归
@ -907,4 +905,3 @@ impl Solution {
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

23
problems/二叉树理论基础.md
View File

@ -8,8 +8,11 @@
# 二叉树理论基础篇 # 二叉树理论基础篇
## 算法公开课
《代码随想录》算法视频公开课：[关于二叉树，你该了解这些！](https://www.bilibili.com/video/BV1Hy4y1t7ij)，相信结合视频在看本篇题解，更有助于大家对本题的理解。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[关于二叉树，你该了解这些！](https://www.bilibili.com/video/BV1Hy4y1t7ij)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 题目分类
题目分类大纲如下： 题目分类大纲如下：
@ -189,8 +192,7 @@ struct TreeNode {
## 其他语言版本 ## 其他语言版本
### Java：
Java：
```java ```java
public class TreeNode { public class TreeNode {
@ -208,8 +210,7 @@ public class TreeNode {
} }
``` ```
### Python：
Python：
```python ```python
class TreeNode: class TreeNode:
@ -219,7 +220,7 @@ class TreeNode:
self.right = right self.right = right
``` ```
Go： ### Go：
```go ```go
type TreeNode struct { type TreeNode struct {
@ -229,7 +230,7 @@ type TreeNode struct {
} }
``` ```
JavaScript： ### JavaScript：
```javascript ```javascript
function TreeNode(val, left, right) { function TreeNode(val, left, right) {
@ -239,7 +240,7 @@ function TreeNode(val, left, right) {
} }
``` ```
TypeScript： ### TypeScript：
```typescript ```typescript
class TreeNode { class TreeNode {
@ -254,7 +255,7 @@ class TreeNode {
} }
``` ```
Swift: ### Swift:
```Swift ```Swift
class TreeNode<T> { class TreeNode<T> {
@ -271,7 +272,7 @@ class TreeNode<T> {
} }
``` ```
Scala: ### Scala:
```scala ```scala
class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) { class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
@ -281,7 +282,7 @@ class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null)
} }
``` ```
rust: ### Rust:
```rust ```rust
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq)]

34
problems/二叉树的统一迭代法.md
View File

@ -5,10 +5,11 @@
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
> 统一写法是一种什么感觉
# 二叉树的统一迭代法 # 二叉树的统一迭代法
> 统一写法是一种什么感觉 ## 思路
此时我们在[二叉树：一入递归深似海，从此offer是路人](https://programmercarl.com/二叉树的递归遍历.html)中用递归的方式，实现了二叉树前中后序的遍历。 此时我们在[二叉树：一入递归深似海，从此offer是路人](https://programmercarl.com/二叉树的递归遍历.html)中用递归的方式，实现了二叉树前中后序的遍历。
@ -28,7 +29,7 @@
如何标记呢，**就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。** 这种方法也可以叫做标记法。 如何标记呢，**就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。** 这种方法也可以叫做标记法。
## 迭代法中序遍历 ### 迭代法中序遍历
中序遍历代码如下：（详细注释） 中序遍历代码如下：（详细注释）
@ -71,7 +72,7 @@ public:
此时我们再来看前序遍历代码。 此时我们再来看前序遍历代码。
## 迭代法前序遍历 ### 迭代法前序遍历
迭代法前序遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**) 迭代法前序遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
@ -102,7 +103,7 @@ public:
}; };
``` ```
## 迭代法后序遍历 ### 迭代法后序遍历
后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**) 后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
@ -143,15 +144,11 @@ public:
所以大家根据自己的个人喜好，对于二叉树的前中后序遍历，选择一种自己容易理解的递归和迭代法。 所以大家根据自己的个人喜好，对于二叉树的前中后序遍历，选择一种自己容易理解的递归和迭代法。
## 其他语言版本
### Java：
# 其他语言版本
Java：
迭代法前序遍历代码如下: 迭代法前序遍历代码如下:
```java ```java
class Solution { class Solution {
public List<Integer> preorderTraversal(TreeNode root) { public List<Integer> preorderTraversal(TreeNode root) {
@ -235,7 +232,7 @@ class Solution {
} }
``` ```
Python： ### Python：
迭代法前序遍历： 迭代法前序遍历：
```python ```python
@ -309,7 +306,8 @@ class Solution:
return result return result
``` ```
Go： ### Go：
> 前序遍历统一迭代法 > 前序遍历统一迭代法
```GO ```GO
@ -442,7 +440,7 @@ func postorderTraversal(root *TreeNode) []int {
} }
``` ```
javaScript: ### JavaScript:
> 前序遍历统一迭代法 > 前序遍历统一迭代法
@ -522,7 +520,7 @@ var postorderTraversal = function(root, res = []) {
``` ```
TypeScript： ### TypeScript：
```typescript ```typescript
// 前序遍历（迭代法） // 前序遍历（迭代法）
@ -591,7 +589,8 @@ function postorderTraversal(root: TreeNode | null): number[] {
return res; return res;
}; };
``` ```
Scala: ### Scala:
```scala ```scala
// 前序遍历 // 前序遍历
object Solution { object Solution {
@ -667,7 +666,7 @@ object Solution {
} }
``` ```
rust: ### Rust:
```rust ```rust
impl Solution{ impl Solution{
@ -747,3 +746,4 @@ impl Solution{
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
</a> </a>

50
problems/二叉树的迭代遍历.md
View File

@ -4,16 +4,17 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
> 听说还可以用非递归的方式
# 二叉树的迭代遍历 # 二叉树的迭代遍历
《代码随想录》算法视频公开课： ## 算法公开课
* [写出二叉树的非递归遍历很难么？（前序和后序）](https://www.bilibili.com/video/BV15f4y1W7i2)
* [写出二叉树的非递归遍历很难么？（中序）)](https://www.bilibili.com/video/BV1Zf4y1a77g)
相信结合视频在看本篇题解，更有助于大家对本题的理解。
[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：
> 听说还可以用非递归的方式 * **[写出二叉树的非递归遍历很难么？（前序和后序）](https://www.bilibili.com/video/BV15f4y1W7i2)**
* **[写出二叉树的非递归遍历很难么？（中序）)](https://www.bilibili.com/video/BV1Zf4y1a77g)**
**相信结合视频在看本篇题解，更有助于大家对本题的理解。**
看完本篇大家可以使用迭代法，再重新解决如下三道leetcode上的题目： 看完本篇大家可以使用迭代法，再重新解决如下三道leetcode上的题目：
@ -21,13 +22,15 @@
* [94.二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal/) * [94.二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal/)
* [145.二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal/) * [145.二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal/)
## 思路
为什么可以用迭代法（非递归的方式）来实现二叉树的前后中序遍历呢？ 为什么可以用迭代法（非递归的方式）来实现二叉树的前后中序遍历呢？
我们在[栈与队列：匹配问题都是栈的强项](https://programmercarl.com/1047.删除字符串中的所有相邻重复项.html)中提到了，**递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中**，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。 我们在[栈与队列：匹配问题都是栈的强项](https://programmercarl.com/1047.删除字符串中的所有相邻重复项.html)中提到了，**递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中**，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
此时大家应该知道我们用栈也可以是实现二叉树的前后中序遍历了。 此时大家应该知道我们用栈也可以是实现二叉树的前后中序遍历了。
## 前序遍历（迭代法） ### 前序遍历（迭代法）
我们先看一下前序遍历。 我们先看一下前序遍历。
@ -69,7 +72,7 @@ public:
但接下来，**再用迭代法写中序遍历的时候，会发现套路又不一样了，目前的前序遍历的逻辑无法直接应用到中序遍历上。** 但接下来，**再用迭代法写中序遍历的时候，会发现套路又不一样了，目前的前序遍历的逻辑无法直接应用到中序遍历上。**
## 中序遍历（迭代法） ### 中序遍历（迭代法）
为了解释清楚，我说明一下 刚刚在迭代的过程中，其实我们有两个操作： 为了解释清楚，我说明一下 刚刚在迭代的过程中，其实我们有两个操作：
@ -112,7 +115,7 @@ public:
``` ```
## 后序遍历（迭代法） ### 后序遍历（迭代法）
再来看后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图： 再来看后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图：
@ -142,7 +145,7 @@ public:
``` ```
# 总结 ## 总结
此时我们用迭代法写出了二叉树的前后中序遍历，大家可以看出前序和中序是完全两种代码风格，并不像递归写法那样代码稍做调整，就可以实现前后中序。 此时我们用迭代法写出了二叉树的前后中序遍历，大家可以看出前序和中序是完全两种代码风格，并不像递归写法那样代码稍做调整，就可以实现前后中序。
@ -155,11 +158,9 @@ public:
当然可以，这种写法，还不是很好理解，我们将在下一篇文章里重点讲解，敬请期待！ 当然可以，这种写法，还不是很好理解，我们将在下一篇文章里重点讲解，敬请期待！
## 其他语言版本
### Java：
# 其他语言版本
Java：
```java ```java
// 前序遍历顺序：中-左-右，入栈顺序：中-右-左 // 前序遍历顺序：中-左-右，入栈顺序：中-右-左
@ -233,10 +234,7 @@ class Solution {
} }
``` ```
### Python：
Python：
```python ```python
# 前序遍历-迭代-LC144_二叉树的前序遍历 # 前序遍历-迭代-LC144_二叉树的前序遍历
@ -281,7 +279,7 @@ class Solution:
# 取栈顶元素右结点 # 取栈顶元素右结点
cur = cur.right cur = cur.right
return result return result
``` ```
```python ```python
# 后序遍历-迭代-LC145_二叉树的后序遍历 # 后序遍历-迭代-LC145_二叉树的后序遍历
@ -303,10 +301,9 @@ class Solution:
stack.append(node.right) stack.append(node.right)
# 将最终的数组翻转 # 将最终的数组翻转
return result[::-1] return result[::-1]
``` ```
### Go：
Go：
> 迭代法前序遍历 > 迭代法前序遍历
@ -400,7 +397,7 @@ func inorderTraversal(root *TreeNode) []int {
} }
``` ```
javaScript： ### JavaScript：
```js ```js
@ -464,7 +461,7 @@ var postorderTraversal = function(root, res = []) {
}; };
``` ```
TypeScript： ### TypeScript：
```typescript ```typescript
// 前序遍历（迭代法） // 前序遍历（迭代法）
@ -519,7 +516,7 @@ function postorderTraversal(root: TreeNode | null): number[] {
}; };
``` ```
Swift： ### Swift：
```swift ```swift
// 前序遍历迭代法 // 前序遍历迭代法
@ -578,7 +575,8 @@ func inorderTraversal(_ root: TreeNode?) -> [Int] {
return result return result
} }
``` ```
Scala: ### Scala:
```scala ```scala
// 前序遍历（迭代法） // 前序遍历（迭代法）
object Solution { object Solution {
@ -645,7 +643,7 @@ object Solution {
} }
``` ```
rust: ### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;

37
problems/二叉树的递归遍历.md
View File

@ -4,15 +4,15 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
> 一看就会，一写就废！
# 二叉树的递归遍历 # 二叉树的递归遍历
## 算法公开课
《代码随想录》算法视频公开课：[每次写递归都要靠直觉？ 这次带你学透二叉树的递归遍历！](https://www.bilibili.com/video/BV1Wh411S7xt)，相信结合视频在看本篇题解，更有助于大家对本题的理解。 **[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[每次写递归都要靠直觉？ 这次带你学透二叉树的递归遍历！](https://www.bilibili.com/video/BV1Wh411S7xt)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
## 思路
> 一看就会，一写就废！
这次我们要好好谈一谈递归，为什么很多同学看递归算法都是“一看就会，一写就废”。 这次我们要好好谈一谈递归，为什么很多同学看递归算法都是“一看就会，一写就废”。
@ -109,14 +109,10 @@ void traversal(TreeNode* cur, vector<int>& vec) {
可能有同学感觉前后中序遍历的递归太简单了，要打迭代法（非递归），别急，我们明天打迭代法，打个通透！ 可能有同学感觉前后中序遍历的递归太简单了，要打迭代法（非递归），别急，我们明天打迭代法，打个通透！
## 其他语言版本
### Java：
# 其他语言版本
Java：
```Java ```Java
// 前序遍历·递归·LC144_二叉树的前序遍历 // 前序遍历·递归·LC144_二叉树的前序遍历
class Solution { class Solution {
@ -171,7 +167,8 @@ class Solution {
} }
``` ```
Python： ### Python：
```python ```python
# 前序遍历-递归-LC144_二叉树的前序遍历 # 前序遍历-递归-LC144_二叉树的前序遍历
# Definition for a binary tree node. # Definition for a binary tree node.
@ -219,7 +216,7 @@ class Solution:
return left + right + [root.val] return left + right + [root.val]
``` ```
Go： ### Go：
前序遍历: 前序遍历:
```go ```go
@ -273,7 +270,7 @@ func postorderTraversal(root *TreeNode) (res []int) {
} }
``` ```
Javascript版本： ### Javascript：
前序遍历： 前序遍历：
```Javascript ```Javascript
@ -327,7 +324,7 @@ var postorderTraversal = function(root) {
}; };
``` ```
TypeScript: ### TypeScript:
```typescript ```typescript
// 前序遍历 // 前序遍历
@ -370,7 +367,7 @@ function postorderTraversal(node: TreeNode | null): number[] {
} }
``` ```
C: ### C:
```c ```c
//前序遍历： //前序遍历：
@ -422,8 +419,9 @@ int* postorderTraversal(struct TreeNode* root, int* returnSize){
} }
``` ```
Swift: ### Swift:
前序遍历：（144.二叉树的前序遍历） 前序遍历：（144.二叉树的前序遍历）
```Swift ```Swift
func preorderTraversal(_ root: TreeNode?) -> [Int] { func preorderTraversal(_ root: TreeNode?) -> [Int] {
var res = [Int]() var res = [Int]()
@ -473,7 +471,10 @@ func postorder(_ root: TreeNode?, res: inout [Int]) {
res.append(root!.val) res.append(root!.val)
} }
``` ```
Scala: 前序遍历：（144.二叉树的前序遍历） ### Scala:
前序遍历：（144.二叉树的前序遍历）
```scala ```scala
object Solution { object Solution {
import scala.collection.mutable.ListBuffer import scala.collection.mutable.ListBuffer
@ -525,7 +526,7 @@ object Solution {
} }
``` ```
rust: ### Rust:
```rust ```rust
use std::cell::RefCell; use std::cell::RefCell;