Skip to content

Commit 78e6286

Browse files
youngyangyang04youngyangyang04
authored
Merge pull request #2587 from markwang1992/102-levelOrder
102.二叉树的层序遍历增加Go使用切片解法
2 parents 2794608 + b2f5b31 commit 78e6286

File tree

1 file changed

+294
-2
lines changed

1 file changed

+294
-2
lines changed

‎problems/0102.二叉树的层序遍历.md‎

Lines changed: 294 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -265,7 +265,7 @@ func levelOrder(root *TreeNode) [][]int {
265265

266266
```go
267267
/**
268-
102. 二叉树的层序遍历
268+
102. 二叉树的层序遍历 使用container包
269269
*/
270270
func levelOrder(root *TreeNode) [][]int {
271271
res := [][]int{}
@@ -296,6 +296,35 @@ func levelOrder(root *TreeNode) [][]int {
296296
return res
297297
}
298298

299+
/**
300+
102. 二叉树的层序遍历 使用切片
301+
*/
302+
func levelOrder(root *TreeNode) [][]int {
303+
res := make([][]int, 0)
304+
if root == nil {
305+
return res
306+
}
307+
queue := make([]*TreeNode, 0)
308+
queue = append(queue, root)
309+
for len(queue) > 0 {
310+
size := len(queue)
311+
level := make([]int, 0)
312+
for i := 0; i < size; i++ {
313+
node := queue[0]
314+
queue = queue[1:]
315+
level = append(level, node.Val)
316+
if node.Left != nil {
317+
queue = append(queue, node.Left)
318+
}
319+
if node.Right != nil {
320+
queue = append(queue, node.Right)
321+
}
322+
}
323+
res = append(res, level)
324+
}
325+
return res
326+
}
327+
299328
/**
300329
102. 二叉树的层序遍历：使用切片模拟队列，易理解
301330
*/
@@ -695,6 +724,41 @@ func levelOrderBottom(root *TreeNode) [][]int {
695724
}
696725
```
697726

727+
```GO
728+
// 使用切片作为队列
729+
func levelOrderBottom(root *TreeNode) [][]int {
730+
res := make([][]int, 0)
731+
if root == nil {
732+
return res
733+
}
734+
queue := make([]*TreeNode, 0)
735+
queue = append(queue, root)
736+
for len(queue) > 0 {
737+
size := len(queue)
738+
level := make([]int, 0)
739+
for i := 0; i < size; i++ {
740+
node := queue[0]
741+
queue = queue[1:]
742+
level = append(level, node.Val)
743+
if node.Left != nil {
744+
queue = append(queue, node.Left)
745+
}
746+
if node.Right != nil {
747+
queue = append(queue, node.Right)
748+
}
749+
}
750+
res = append(res, level)
751+
}
752+
l, r := 0, len(res)-1
753+
for l < r {
754+
res[l], res[r] = res[r], res[l]
755+
l++
756+
r--
757+
}
758+
return res
759+
}
760+
```
761+
698762
#### Javascript:
699763

700764
```javascript
@@ -1008,6 +1072,35 @@ func rightSideView(root *TreeNode) []int {
10081072
}
10091073
```
10101074

1075+
```GO
1076+
// 使用切片作为队列
1077+
func rightSideView(root *TreeNode) []int {
1078+
res := make([]int, 0)
1079+
if root == nil {
1080+
return res
1081+
}
1082+
queue := make([]*TreeNode, 0)
1083+
queue = append(queue, root)
1084+
for len(queue) > 0 {
1085+
size := len(queue)
1086+
for i := 0; i < size; i++ {
1087+
node := queue[0]
1088+
queue = queue[1:]
1089+
if node.Left != nil {
1090+
queue = append(queue, node.Left)
1091+
}
1092+
if node.Right != nil {
1093+
queue = append(queue, node.Right)
1094+
}
1095+
if i == size-1 {
1096+
res = append(res, node.Val)
1097+
}
1098+
}
1099+
}
1100+
return res
1101+
}
1102+
```
1103+
10111104
#### Javascript:
10121105

10131106
```javascript
@@ -1299,6 +1392,35 @@ func averageOfLevels(root *TreeNode) []float64 {
12991392
}
13001393
```
13011394

1395+
```GO
1396+
// 使用切片作为队列
1397+
func averageOfLevels(root *TreeNode) []float64 {
1398+
res := make([]float64, 0)
1399+
if root == nil {
1400+
return res
1401+
}
1402+
queue := make([]*TreeNode, 0)
1403+
queue = append(queue, root)
1404+
for len(queue) > 0 {
1405+
size := len(queue)
1406+
sum := 0
1407+
for i := 0; i < size; i++ {
1408+
node := queue[0]
1409+
queue = queue[1:]
1410+
sum += node.Val
1411+
if node.Left != nil {
1412+
queue = append(queue, node.Left)
1413+
}
1414+
if node.Right != nil {
1415+
queue = append(queue, node.Right)
1416+
}
1417+
}
1418+
res = append(res, float64(sum)/float64(size))
1419+
}
1420+
return res
1421+
}
1422+
```
1423+
13021424
#### Javascript：
13031425

13041426
```javascript
@@ -1631,6 +1753,32 @@ func levelOrder(root *Node) [][]int {
16311753
}
16321754
```
16331755

1756+
```GO
1757+
// 使用切片作为队列
1758+
func levelOrder(root *Node) [][]int {
1759+
res := make([][]int, 0)
1760+
if root == nil {
1761+
return res
1762+
}
1763+
queue := make([]*Node, 0)
1764+
queue = append(queue, root)
1765+
for len(queue) > 0 {
1766+
size := len(queue)
1767+
level := make([]int, 0)
1768+
for i := 0; i < size; i++ {
1769+
node := queue[0]
1770+
queue = queue[1:]
1771+
level = append(level, node.Val)
1772+
if len(node.Children) > 0 {
1773+
queue = append(queue, node.Children...)
1774+
}
1775+
}
1776+
res = append(res, level)
1777+
}
1778+
return res
1779+
}
1780+
```
1781+
16341782
#### JavaScript：
16351783

16361784
```JavaScript
@@ -1930,6 +2078,37 @@ func max(x, y int) int {
19302078
}
19312079
```
19322080

2081+
```GO
2082+
// 使用切片作为队列
2083+
func largestValues(root *TreeNode) []int {
2084+
res := make([]int, 0)
2085+
if root == nil {
2086+
return res
2087+
}
2088+
queue := make([]*TreeNode, 0)
2089+
queue = append(queue, root)
2090+
for len(queue) > 0 {
2091+
size := len(queue)
2092+
maxValue := math.MinInt64
2093+
for i := 0; i < size; i++ {
2094+
node := queue[0]
2095+
queue = queue[1:]
2096+
if node.Val > maxValue {
2097+
maxValue = node.Val
2098+
}
2099+
if node.Left != nil {
2100+
queue = append(queue, node.Left)
2101+
}
2102+
if node.Right != nil {
2103+
queue = append(queue, node.Right)
2104+
}
2105+
}
2106+
res = append(res, maxValue)
2107+
}
2108+
return res
2109+
}
2110+
```
2111+
19332112
#### Javascript：
19342113

19352114
```javascript
@@ -2243,6 +2422,34 @@ func connect(root *Node) *Node {
22432422

22442423
```
22452424

2425+
```GO
2426+
// 使用切片作为队列
2427+
func connect(root *Node) *Node {
2428+
if root == nil {
2429+
return root
2430+
}
2431+
queue := make([]*Node, 0)
2432+
queue = append(queue, root)
2433+
for len(queue) > 0 {
2434+
size := len(queue)
2435+
for i := 0; i < size; i++ {
2436+
node := queue[i]
2437+
if i != size - 1 {
2438+
queue[i].Next = queue[i+1]
2439+
}
2440+
if node.Left != nil {
2441+
queue = append(queue, node.Left)
2442+
}
2443+
if node.Right != nil {
2444+
queue = append(queue, node.Right)
2445+
}
2446+
}
2447+
queue = queue[size:]
2448+
}
2449+
return root
2450+
}
2451+
```
2452+
22462453
#### JavaScript:
22472454

22482455
```javascript
@@ -2531,6 +2738,34 @@ func connect(root *Node) *Node {
25312738
}
25322739
```
25332740

2741+
```GO
2742+
// 使用切片作为队列
2743+
func connect(root *Node) *Node {
2744+
if root == nil {
2745+
return root
2746+
}
2747+
queue := make([]*Node, 0)
2748+
queue = append(queue, root)
2749+
for len(queue) > 0 {
2750+
size := len(queue)
2751+
for i := 0; i < size; i++ {
2752+
node := queue[i]
2753+
if i != size - 1 {
2754+
queue[i].Next = queue[i+1]
2755+
}
2756+
if node.Left != nil {
2757+
queue = append(queue, node.Left)
2758+
}
2759+
if node.Right != nil {
2760+
queue = append(queue, node.Right)
2761+
}
2762+
}
2763+
queue = queue[size:]
2764+
}
2765+
return root
2766+
}
2767+
```
2768+
25342769
#### JavaScript:
25352770

25362771
```javascript
@@ -2800,6 +3035,33 @@ func maxDepth(root *TreeNode) int {
28003035
}
28013036
```
28023037

3038+
```go
3039+
// 使用切片作为队列
3040+
func maxDepth(root *TreeNode) int {
3041+
if root == nil {
3042+
return 0
3043+
}
3044+
depth := 0
3045+
queue := make([]*TreeNode, 0)
3046+
queue = append(queue, root)
3047+
for len(queue) > 0 {
3048+
size := len(queue)
3049+
for i := 0; i < size; i++ {
3050+
node := queue[0]
3051+
queue = queue[1:]
3052+
if node.Left != nil {
3053+
queue = append(queue, node.Left)
3054+
}
3055+
if node.Right != nil {
3056+
queue = append(queue, node.Right)
3057+
}
3058+
}
3059+
depth++
3060+
}
3061+
return depth
3062+
}
3063+
```
3064+
28033065
#### JavaScript：
28043066

28053067
```javascript
@@ -3073,7 +3335,37 @@ func minDepth(root *TreeNode) int {
30733335
ans++//记录层数
30743336
}
30753337

3076-
return ans+1
3338+
return ans
3339+
}
3340+
```
3341+
3342+
```go
3343+
// 使用切片作为队列
3344+
func minDepth(root *TreeNode) int {
3345+
if root == nil {
3346+
return 0
3347+
}
3348+
depth := 0
3349+
queue := make([]*TreeNode, 0)
3350+
queue = append(queue, root)
3351+
for len(queue) > 0 {
3352+
size := len(queue)
3353+
depth++
3354+
for i := 0; i < size; i++ {
3355+
node := queue[0]
3356+
queue = queue[1:]
3357+
if node.Left != nil {
3358+
queue = append(queue, node.Left)
3359+
}
3360+
if node.Right != nil {
3361+
queue = append(queue, node.Right)
3362+
}
3363+
if node.Left == nil && node.Right == nil {
3364+
return depth
3365+
}
3366+
}
3367+
}
3368+
return depth
30773369
}
30783370
```
30793371

0 commit comments

Comments
 (0)