Day13 Golang （二叉树）二叉树的层序遍历题组

已于 2024-01-24 16:32:43 修改
阅读量353 收藏 8
点赞数 8
分类专栏： 代码随想录60天刷题 文章标签： 算法 golang
于 2024-01-23 21:57:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fdyw_gzl/article/details/135788723
版权 
// 102.二叉树的层序遍历
package main

import (
	"container/list"
	"fmt"
)

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func levelOrder(root *TreeNode) [][]int {
	res := [][]int{}
	que := list.New()
	if root != nil {
		que.PushBack(root)
	} else {
		return nil
	}
	for que.Len() > 0 {
		length := que.Len() //记录每层结点的数量
		res_row := []int{}  //存放每层结点的值
		for length > 0 {
			node := que.Remove(que.Front()).(*TreeNode) //队首结点出队列
			res_row = append(res_row, node.Val)
			//加入出列结点的左右孩子
			if node.Left != nil {
				que.PushBack(node.Left)
			}
			if node.Right != nil {
				que.PushBack(node.Right)
			}

			length--
		}
		res = append(res, res_row)
	}
	return res
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := levelOrder(&node7)
	fmt.Printf("res: %v\n", res)//res: [[5] [4 6] [1 2 7 8]]
}

// 05 107.二叉树的层次遍历II(opens new window)
package main

import (
	"container/list"
	"fmt"
)

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func levelOrderBottom(root *TreeNode) [][]int {
	res := [][]int{}
	que := list.New()
	if root != nil {
		que.PushBack(root)
	} else {
		return nil
	}
	for que.Len() > 0 {
		res_row := []int{}
		length := que.Len()
		for length > 0 {
			val := que.Remove(que.Front()).(*TreeNode)
			res_row = append(res_row, val.Val)
			if val.Left != nil {
				que.PushBack(val.Left)
			}
			if val.Right != nil {
				que.PushBack(val.Right)
			}
			length--
		}
		res = append(res, res_row)
	}
	for i, j := 0, len(res)-1; i < len(res)/2; i++ { //反转数组
		res[i], res[j] = res[j], res[i]
		j--
	}
	return res
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := levelOrderBottom(&node7)
	fmt.Printf("res: %v\n", res) //res: [[1 2 7 8] [4 6] [5]]
}
// 06 199.二叉树的右视图
package main

import (
	"container/list"
	"fmt"
)

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func rightSideView(root *TreeNode) []int {
	res := [][]int{}
	que := list.New()
	result := []int{}
	if root != nil {
		que.PushBack(root)
	} else {
		return nil
	}
	for que.Len() > 0 {
		length := que.Len()
		res_row := []int{}
		for length > 0 {
			val := que.Remove(que.Front()).(*TreeNode)
			res_row = append(res_row, val.Val)
			if val.Left != nil {
				que.PushBack(val.Left)
			}
			if val.Right != nil {
				que.PushBack(val.Right)
			}
			length--
		}
		res = append(res, res_row)
	}
	for _, v := range res { //取每一个数组最后一个元素
		result = append(result, v[len(v)-1])
	}
	return result
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := rightSideView(&node7)
	fmt.Printf("res: %v\n", res) //res: [5 6 8]
}
// 07 637.二叉树的层平均值(opens new window)
package main

import (
	"container/list"
	"fmt"
)

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func averageOfLevels(root *TreeNode) []float64 {
	res := [][]int{}
	que := list.New()
	result := []float64{}
	if root != nil {
		que.PushBack(root)
	} else {
		return nil
	}
	for que.Len() > 0 {
		length := que.Len()
		res_row := []int{}
		for length > 0 {
			val := que.Remove(que.Front()).(*TreeNode)
			res_row = append(res_row, val.Val)
			if val.Left != nil {
				que.PushBack(val.Left)
			}
			if val.Right != nil {
				que.PushBack(val.Right)
			}
			length--
		}
		res = append(res, res_row)
	}
	for _, v := range res {
		add := 0.0
		for _, v2 := range v {
			add += float64(v2)
		}
		result = append(result, add/float64(len(v)))
	}
	return result
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := averageOfLevels(&node7)
	fmt.Printf("res: %v\n", res) //res: [5 6 8]
}
//08 429.N叉树的层序遍历(opens new window)
package main

import (
	"container/list"
	"fmt"
)

// Definition for a Node.
type Node struct {
	Val      int
	Children []*Node
}

func levelOrder(root *Node) [][]int {
	res := [][]int{}
	que := list.New()
	if root != nil {
		que.PushBack(root)
	} else {
		return nil
	}
	for que.Len() > 0 {
		length := que.Len()
		res_row := []int{}
		for length > 0 {
			val := que.Remove(que.Front()).(*Node)
			res_row = append(res_row, val.Val)
			for _, v := range val.Children { //将该结点的所有的子结点压入栈
				if v != nil {
					que.PushBack(v)
				}
			}
			length--
		}
		res = append(res, res_row)
	}
	return res
}

func main() {
	//k=3
	node5, node6 := Node{5, nil}, Node{2, nil}
	//k=2
	node3 := Node{3, []*Node{&node5, &node6}} //注意这里的切片赋值
	node2 := Node{2, nil}
	node4 := Node{4, nil}
	//k=1
	node1 := Node{1, []*Node{&node3, &node2, &node4}}
	res := levelOrder(&node1)
	fmt.Printf("res: %v\n", res)//res: [[1] [3 2 4] [5 2]]

}
// 515.在每个树行中找最大值(opens new window)
package main

import (
	"container/list"
	"fmt"
	"math"
)

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func largestValues(root *TreeNode) []int {
	res := []int{}
	que := list.New()
	if root != nil {
		que.PushBack(root)
	} else {
		return nil
	}
	for que.Len() > 0 {
		length := que.Len()   //记录每层结点的数量
		res_row := []int{}    //存放每层结点的值
		temp := math.MinInt64 //临时变量保存每层的最大值,初始化为最小的Int64数
		for length > 0 {
			node := que.Remove(que.Front()).(*TreeNode) //队首结点出队列
			res_row = append(res_row, node.Val)
			temp = Max(temp, node.Val) //注意math.Max的用法
			//加入出列结点的左右孩子
			if node.Left != nil {
				que.PushBack(node.Left)
			}
			if node.Right != nil {
				que.PushBack(node.Right)
			}

			length--
		}
		res = append(res, int(temp))
	}
	return res
}
func Max(x int, y int) int {
	if x < y {
		return y
	} else {
		return x
	}
}
func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := largestValues(&node7)
	fmt.Printf("res: %v\n", res)
}
// 116.填充每个节点的下一个右侧节点指针(opens new window)
// 117.填充每个节点的下一个右侧节点指针II
package main

import (
	"container/list"
	"fmt"
)

type Node struct {
	Val   int
	Left  *Node
	Right *Node
	Next  *Node
}

func connect(root *Node) *Node {
	que := list.New()
	if root != nil {
		que.PushBack(root)
	} else {
		return nil
	}
	for que.Len() > 0 {
		length := que.Len()
		que_row := make([]*Node, 0)
		for length > 0 {
			val := que.Remove(que.Front()).(*Node)
			que_row = append(que_row, val)
			if val.Left != nil {
				que.PushBack(val.Left)
			}
			if val.Right != nil {
				que.PushBack(val.Right)
			}
			length--
		}
		for i, _ := range que_row { //遍历每一层结点
			if i < len(que_row)-1 {
				que_row[i].Next = que_row[i+1] //结点指向下一个结点
			} else {
				que_row[i].Next = nil //最后一个结点指向空
			}

		}
	}
	return root
}

func main() {
	//k=3
	node1, node2, node3, node4 := Node{1, nil, nil, nil}, Node{2, nil, nil, nil}, Node{7, nil, nil, nil}, Node{8, nil, nil, nil}
	//k=2
	node5, node6 := Node{4, &node1, &node2, nil}, Node{6, &node3, &node4, nil}
	//k=1
	node7 := Node{5, &node5, &node6, nil}
	res := connect(&node7)
	fmt.Printf("res: %v\n", res) //res: &{5 0xc000052440 0xc000052460 <nil>}
}

// 104.二叉树的最大深度(opens new window)
package main

import (
	"container/list"
	"fmt"
)

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func maxDepth(root *TreeNode) int {
	que := list.New()
	depth := 0
	que.PushBack(root) //根结点入队列
	if root == nil {   //注意排除空结点的情况
		return 0
	}
	for que.Len() > 0 {
		length := que.Len()
		for length > 0 {
			val := que.Remove(que.Front()).(*TreeNode)
			if val.Left != nil {
				que.PushBack(val.Left)
			}
			if val.Right != nil {
				que.PushBack(val.Right)
			}
			length--
		}
		depth++
	}
	return depth
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := maxDepth(&node7)
	fmt.Printf("res: %v\n", res)
}
// 111.二叉树的最小深度
package main

import (
	"container/list"
	"fmt"
)

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func minDepth(root *TreeNode) int {
	if root == nil { //注意排除空结点的情况
		return 0
	}
	que := list.New()
	depth := 1
	que.PushBack(root) //根结点入队列
	if root == nil {   //注意排除空结点的情况
		return 0
	}
	for que.Len() > 0 {
		length := que.Len()
		for length > 0 {
			val := que.Remove(que.Front()).(*TreeNode)
			if val.Left == nil && val.Right == nil { //如果遍历到叶子结点，直接返回深度
				return depth
			}
			if val.Left != nil {
				que.PushBack(val.Left)
			}
			if val.Right != nil {
				que.PushBack(val.Right)
			}
			length--
		}
		depth++
	}
	return depth
}

func main() {
	//k=3
	node1, node2, node3, node4 := TreeNode{1, nil, nil}, TreeNode{2, nil, nil}, TreeNode{7, nil, nil}, TreeNode{8, nil, nil}
	//k=2
	node5, node6 := TreeNode{4, &node1, &node2}, TreeNode{6, &node3, &node4}
	//k=1
	node7 := TreeNode{5, &node5, &node6}
	res := minDepth(&node7)
	fmt.Printf("res: %v\n", res) //res: 3
}

风的余温zl
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
代码随想录day15｜层序遍历10道｜226.翻转二叉树｜101. 对称二叉树
weixin_42161901的博客
10-06 474
笔记
Day12 Golang (二叉树) 144.二叉树的前序遍历(opens new window)145.二叉树的后序遍历(opens new window)94.二叉树的中序遍历
fdyw_gzl的博客
01-21 368
【代码】Day12 Golang (二叉树) 144.二叉树的前序遍历(opens new window)145.二叉树的后序遍历(opens new window)94.二叉树的中序遍历。
Leetcode 102. 二叉树的层序遍历（DAY 87） ---- Leetcode Hot 100
Love 6's Private Blog
04-16 238
原题题目 代码实现（首刷自解） /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), left(nullptr), rig
Day14 Golang (二叉树) 226.翻转二叉树 101.对称二叉树
fdyw_gzl的博客
01-25 379
【代码】Day14 Golang (二叉树) 226.翻转二叉树 101.对称二叉树
Leetcode 103. 二叉树的锯齿形层序遍历（DAY 153）---- LeetCode 精选 TOP 面试题
Love 6's Private Blog
08-25 151
文章目录原题题目代码实现（首刷自解） 原题题目 代码实现（首刷自解） /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(
Day17 Golang (二叉树) 110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和
fdyw_gzl的博客
01-29 390
【代码】Day17 Golang (二叉树) 110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和。
代码随想录day14｜二叉树来咯｜理论基础｜前中后序遍历｜Golang｜
weixin_42161901的博客
10-04 406
笔记
Day16 Golang （二叉树）104.二叉树的最大深度 559.n叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数
fdyw_gzl的博客
01-25 352
【代码】Day16 Golang （二叉树）104.二叉树的最大深度 559.n叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数
【Golang每日一练】（更新到Day0140）
汉阳Hann's Home
03-13 1610
​1. 两数之和 Two Sum 2.两数相加 Add Two Numbers 3.无重复字符的最长子串 Longest-substring-without-repeating-characters 4. 寻找两个正序数组的中位数Median of two sorted arrays 5. 最长回文子串 Longest Palindromic Substring 6. Z字形变换 Zigzag Conversion 7. 整数反转 Reverse Integer ..... 8. 字符串转换整 ......
深入遍历二叉树的各种操作详解（非递归遍历）
01-01
先使用先序的方法建立一棵二叉树，然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树，并使用了两种方法来进行层次遍历二叉树，一种方法就是使用STL中的queue，另外一种方法就是定义了一个数组队列，...
golang 50k 高阶面试题
06-28
go大厂都面试什么
Golang排列组合算法问题之全排列实现方法
12-26
本文实例讲述了Golang排列组合算法问题之全排列实现方法。分享给大家供大家参考，具体如下： 【排列组合问题】 一共N辆火车（0<N<10），每辆火车以数字1-9编号，要求以字典序排序输出火车出站的序列号。 输入:...
golang中for循环遍历channel时需要注意的问题详解
09-20
主要给大家介绍了关于golang中for循环遍历channel时需要注意的问题的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 605
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 667
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 254
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
【算法】插入排序
贱贱的剑
07-03 1003
介绍了两种不同的插入排序算法，以及效率对比
LSH算法：高效相似性搜索的原理与Python实现II
uncle_ll的博客
07-02 925
lsh基于随机平面的实现
用golang实现二叉树中遍历的代码
03-24
当然可以，以下是一个简单的二叉树遍历的实现代码： ```go type TreeNode struct { Val int Left *TreeNode Right *TreeNode } func inorderTraversal(root *TreeNode) []int { if root == nil { return []int{} } res := []int{} stack := []*TreeNode{} cur := root for cur != nil || len(stack) > 0 { for cur != nil { stack = append(stack, cur) cur = cur.Left } cur = stack[len(stack)-1] stack = stack[:len(stack)-1] res = append(res, cur.Val) cur = cur.Right } return res } ``` 这是一个中序遍历的实现，其他遍历方式可以类似地实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值