您好,登錄后才能下訂單哦!
本篇文章給大家分享的是有關如何理解二叉樹的層次遍歷,小編覺得挺實用的,因此分享給大家學習,希望大家閱讀完這篇文章后可以有所收獲,話不多說,跟著小編一起來看看吧。
算法:
樹的層次遍歷是樹的基本操作之一,包括二叉樹的層次遍歷,多叉樹的層次遍歷,以及二叉樹層次遍歷的變形題目,層次遍歷+每一層的節點的翻轉等操作。
對于這類題目,典型算法就是先將樹按照層次存入數組當中,然后統一對每一層的數據進行數據處理。
題目1:
代碼實現:
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
/*
方法1:非遞歸操作
*/
/*
func levelOrder(root *TreeNode) [][]int {
if root == nil {
return nil
}
var stack []*TreeNode
var result [][]int
stack = append(stack,root)
for {
if len(stack) == 0 {
break;
}
res,stack1 := helper(stack)
if len(res) != 0 {
result = append(result,res)
}
stack = stack1
}
return result
}
func helper(stack []*TreeNode)(res []int, stackRes []*TreeNode){
if len(stack) == 0{
return
}
for i:=0;i<len(stack); i++{
node := stack[i]
if node == nil {
continue
}
res = append(res,node.Val)
stackRes = append(stackRes,node.Left)
stackRes = append(stackRes,node.Right)
}
return
}
*/
/*
解法:隊列來操作,
樹的層次遍歷,從左到右遍歷樹的每一層存入對應的數組即可
*/
/*
方法2:遞歸操作
利用二叉樹的先序遍歷方法,也就是先訪問根節點,在訪問做左孩子,然后訪問右孩子。
*/
func levelOrder(root *TreeNode) [][]int {
return preOrder(root, 0, [][]int{})
}
func preOrder(root *TreeNode, level int, res [][]int) [][]int {
if root == nil {
return res
}
// 1.根節點的處理
// 這里因為level從0開始計算的緣故,len放進去值之后就是1,所以==的時候,便是是新的一層開始
if level == len(res) {
res = append(res,[]int{root.Val})
} else {
res[level] = append(res[level],root.Val)
}
// 2.左孩子節點的處理
res = preOrder(root.Left,level+1,res)
// 3.右孩子節點的處理
res = preOrder(root.Right,level+1,res)
return res
}
執行結果:
題目2:
https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/
代碼實現:
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func levelOrderBottom(root *TreeNode) [][]int {
r := [][]int{}
order(root,0,&r)
for i,j:= 0, len(r)-1;i<j;{
r[i],r[j] = r[j],r[i]
i++
j--
}
return r
}
func order(root *TreeNode,level int,res *[][]int) {
if root == nil {
return
}
if len(*res)-1 < level {
*res = append(*res,[]int{root.Val})
} else {
(*res)[level] = append((*res)[level],root.Val)
}
order(root.Left,level+1,res)
order(root.Right,level+1,res)
return
}
執行結果:
題目3:
https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/
代碼實現:
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func zigzagLevelOrder(root *TreeNode) [][]int {
if root == nil {
return nil
}
res := [][]int{}
levelOrder(root,0, &res)
for i:=0; i< len(res); i++ {
if i%2 == 1{
j,k:=0,len(res[i])-1
for j < k{
res[i][j],res[i][k] = res[i][k],res[i][j]
j++
k--
}
}
}
return res
}
func levelOrder(root *TreeNode, l int, res *[][]int) {
if root == nil {
return
}
if len(*res)-1 < l {
*res = append(*res,[]int{root.Val})
} else {
(*res)[l] = append((*res)[l],root.Val)
}
levelOrder(root.Left,l+1,res)
levelOrder(root.Right,l+1,res)
return
}
// 需要: 先按照層次去遍歷存儲,然后統一的做整理,調整需要轉換的對應層次
結果輸出:
題目4.
https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/
代碼實現:
/**
* Definition for a Node.
* type Node struct {
* Val int
* Children []*Node
* }
*/
func levelOrder(root *Node) [][]int {
if root == nil {
return nil
}
res := [][]int{}
levelOrderOk(root,0,&res)
return res
}
func levelOrderOk(root *Node,l int, res *[][]int){
if len(*res)-1 < l {
*res = append(*res,[]int{root.Val})
} else {
(*res)[l] = append((*res)[l],root.Val)
}
for _,t := range root.Children {
levelOrderOk(t,l+1,res)
}
return
}
執行結果:
以上就是如何理解二叉樹的層次遍歷,小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。
免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。