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

Merge pull request #2587 from markwang1992/102-levelOrder

Browse Source 
102.二叉树的层序遍历增加Go使用切片解法
This commit is contained in:
程序员Carl
2024-07-07 17:07:55 +08:00
committed by GitHub
parent 27946081cc b2f5b31987
commit 78e6286b7e
1 changed files with 294 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -265,7 +265,7 @@ func levelOrder(root *TreeNode) [][]int {
```go
/**
102. 二叉树的层序遍历
102. 二叉树的层序遍历 使用container包
*/
func levelOrder(root *TreeNode) [][]int {
res := [][]int{}
@ -296,6 +296,35 @@ func levelOrder(root *TreeNode) [][]int {
return res
}
/**
102. 二叉树的层序遍历 使用切片
*/
func levelOrder(root *TreeNode) [][]int {
res := make([][]int, 0)
if root == nil {
return res
}
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
level := make([]int, 0)
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
level = append(level, node.Val)
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
res = append(res, level)
}
return res
}
/**
102. 二叉树的层序遍历：使用切片模拟队列，易理解
*/
@ -695,6 +724,41 @@ func levelOrderBottom(root *TreeNode) [][]int {
}
```
```GO
// 使用切片作为队列
func levelOrderBottom(root *TreeNode) [][]int {
res := make([][]int, 0)
if root == nil {
return res
}
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
level := make([]int, 0)
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
level = append(level, node.Val)
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
res = append(res, level)
}
l, r := 0, len(res)-1
for l < r {
res[l], res[r] = res[r], res[l]
l++
r--
}
return res
}
```
#### Javascript:
```javascript
@ -1008,6 +1072,35 @@ func rightSideView(root *TreeNode) []int {
}
```
```GO
// 使用切片作为队列
func rightSideView(root *TreeNode) []int {
res := make([]int, 0)
if root == nil {
return res
}
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
if i == size-1 {
res = append(res, node.Val)
}
}
}
return res
}
```
#### Javascript:
```javascript
@ -1299,6 +1392,35 @@ func averageOfLevels(root *TreeNode) []float64 {
}
```
```GO
// 使用切片作为队列
func averageOfLevels(root *TreeNode) []float64 {
res := make([]float64, 0)
if root == nil {
return res
}
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
sum := 0
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
sum += node.Val
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
res = append(res, float64(sum)/float64(size))
}
return res
}
```
#### Javascript：
```javascript
@ -1631,6 +1753,32 @@ func levelOrder(root *Node) [][]int {
}
```
```GO
// 使用切片作为队列
func levelOrder(root *Node) [][]int {
res := make([][]int, 0)
if root == nil {
return res
}
queue := make([]*Node, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
level := make([]int, 0)
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
level = append(level, node.Val)
if len(node.Children) > 0 {
queue = append(queue, node.Children...)
}
}
res = append(res, level)
}
return res
}
```
#### JavaScript：
```JavaScript
@ -1930,6 +2078,37 @@ func max(x, y int) int {
}
```
```GO
// 使用切片作为队列
func largestValues(root *TreeNode) []int {
res := make([]int, 0)
if root == nil {
return res
}
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
maxValue := math.MinInt64
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
if node.Val > maxValue {
maxValue = node.Val
}
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
res = append(res, maxValue)
}
return res
}
```
#### Javascript：
```javascript
@ -2243,6 +2422,34 @@ func connect(root *Node) *Node {
```
```GO
// 使用切片作为队列
func connect(root *Node) *Node {
if root == nil {
return root
}
queue := make([]*Node, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
for i := 0; i < size; i++ {
node := queue[i]
if i != size - 1 {
queue[i].Next = queue[i+1]
}
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
queue = queue[size:]
}
return root
}
```
#### JavaScript:
```javascript
@ -2531,6 +2738,34 @@ func connect(root *Node) *Node {
}
```
```GO
// 使用切片作为队列
func connect(root *Node) *Node {
if root == nil {
return root
}
queue := make([]*Node, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
for i := 0; i < size; i++ {
node := queue[i]
if i != size - 1 {
queue[i].Next = queue[i+1]
}
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
queue = queue[size:]
}
return root
}
```
#### JavaScript:
```javascript
@ -2800,6 +3035,33 @@ func maxDepth(root *TreeNode) int {
}
```
```go
// 使用切片作为队列
func maxDepth(root *TreeNode) int {
if root == nil {
return 0
}
depth := 0
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
}
depth++
}
return depth
}
```
#### JavaScript：
```javascript
@ -3073,7 +3335,37 @@ func minDepth(root *TreeNode) int {
ans++//记录层数
}
return ans+1
return ans
}
```
```go
// 使用切片作为队列
func minDepth(root *TreeNode) int {
if root == nil {
return 0
}
depth := 0
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
size := len(queue)
depth++
for i := 0; i < size; i++ {
node := queue[0]
queue = queue[1:]
if node.Left != nil {
queue = append(queue, node.Left)
}
if node.Right != nil {
queue = append(queue, node.Right)
}
if node.Left == nil && node.Right == nil {
return depth
}
}
}
return depth
}
```