算法60-BFS

题目

1一次打印数的每一层
2 求最大一层的节点数

分析

宽度优先遍历

可以借助队列实现

代码：

package main

import (
	"github.com/goSTL/Data_structure/queue"
    "fmt"
    "math"
    
)
type TreeNode struct {
	Value int
    // 左子树指针
    left *TreeNode
    // 右子树指针
    right *TreeNode
}
//宽度优先遍历
//头结点先进队列，每次弹出时先进左孩子节点，再进右孩子节点
func bfs(tree *TreeNode){
	q := queue.New()
    q.Push(tree)
    for !q.Empty(){
        tmp:=q.Pop()
        switch tmp.(type){//注意reflect的格式 .(type)
        case *TreeNode:
            v,ok:=tmp.(*TreeNode)//一定要加这一句才能转换，强转类型
            if ok{
                fmt.Println(v.Value)
                if v.left !=nil{
                    q.Push(v.left)
                }
                if v.right !=nil{
                    q.Push(v.right)
                }
            }
        }
    }
}
//用一个map记录那个节点在第几层，进入队列时依据节点关系记录在map
//当前计算哪一层
//当前层最大节点数
//队列弹出的节点在第几层
//以上四个参数足以求出max
func bfs1(tree *TreeNode){
	q := queue.New()
    q.Push(tree)
    level:=make(map[int]int)
    level[tree.Value]=1
    currentlevel:=1//当前计算的层
    curnodecount:=0//当前计算层的节点数
    maxlevelnodes:=0//最大的节点数
    for !q.Empty(){
        tmp:=q.Pop()
        switch tmp.(type){//注意reflect的格式 .(type)
        case *TreeNode:
            v,ok:=tmp.(*TreeNode)//一定要加这一句才能转换，强转类型
            if ok{
                // fmt.Println(v.Value)
                curnodelevel:=level[v.Value]//弹出的元素在第几层
                fmt.Printf("curretn level %v\n",level[v.Value])
                // fmt.Printf("curretn level %v\n",level[v.Value])

                if v.left !=nil{
                    level[v.left.Value]=level[v.Value]+1//记录子节点的层数

                    q.Push(v.left)
                }
                if v.right !=nil{
                    level[v.right.Value]=level[v.Value]+1//记录子节点的层数

                    q.Push(v.right)
                }
                if currentlevel == curnodelevel{//弹出的元素是当前计算的层
                    curnodecount++//当前计算层的节点数++
                }else{//否则就表示计算当潜藏计算完了，结算最大节点数
                    maxlevelnodes=int(math.Max(float64(maxlevelnodes),float64(curnodecount)))
                    currentlevel++//一层计算完了，计算的层数加1
                    curnodecount=1//当前层的节点数恢复到1，因为要算上现在弹出的这一个
                }
            }
        }
    }
    fmt.Println(maxlevelnodes)
}




func main() {
    // 根节点

	var root TreeNode
	root.Value=18

    
    // 一级左子树
	var left1 TreeNode
	left1.Value=5
    root.left = &left1
    
    // 一级右子树
	var right1 TreeNode
	right1.Value=20
    root.right = &right1
   
    
    var right2 TreeNode
	right2.Value=4
    right1.right = &right2
    // 二级左子树
    var left2 TreeNode
    left2.Value=3
    left1.left = &left2

	// 三级右子树
	var left3 TreeNode
    left3.Value=8
    left1.right = &left3

	//四级右子树
	var left4 TreeNode
    left4.Value=12
    left3.right = &left4

	//五级右子树
	var left5 TreeNode
	left5.Value=15
	left4.right = &left5
    
    // 调用前序遍历函数
    // PreOrder(&root)
	// MidOrder(&root)
	bfs1(&root)
    // var s Stack = make([]TreeNode,0)

	// q := queue.New()

    // q.Push(&root)

    // fmt.Println(q.Pop())
    // fmt.Println(q.Empty())

    // s.push(&root)
    // s.push(&left1)
    // fmt.Println(s.peek())
    // PreOrder1(&root)
    // MidOrder1(&root)
}