leetcode golang刷题总结——二叉树

二叉树的镜像

输入一个二叉树，该函数输出镜像

思路：采用层次遍历。

1. 根节点入队，出兑，翻转左右节点
2. 左右节点入队，出队，翻转
3. 直到队列为空，已遍历所有节点

func mirrorTree(root *TreeNode) *TreeNode {
    if root==nil{
        return root
    }
    var a []*TreeNode
	a=append(a,root)
	for len(a)!=0{
		t:=a[0]
		a=a[1:]
		t.Left,t.Right=t.Right,t.Left
		if t.Left!=nil{
			a=append(a,t.Left)
		}
		if t.Right!=nil{
			a=append(a,t.Right)
		}
	}
	return root
}

对称的二叉树

判断二叉树是不是对称的，如果二叉树和它的镜像一样，则对称

思路：如果两个子树 p 和 q 是对称的，那么

p.Val == q.Val
p.Left 和 q.Right 是对称的
p.Right 和 q.Left 是对称的

这就形成了一个递归的过程

func isSymmetric(root *TreeNode) bool {
    if root ==nil{
        return true
    }
    return judgeSymmetric(root.Left,root.Right)
}
func judgeSymmetric(a,b *TreeNode)bool{
    if a==nil&&b==nil{
        return true
    }
    if a==nil&&b!=nil{
        return false
    }
    if a!=nil&&b==nil{
        return false
    }
    if a.Val!=b.Val{
        return false
    }
    return judgeSymmetric(a.Left,b.Right)&&judgeSymmetric(a.Right,b.Left)
}

从上到下打印二叉树

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

思路：采用层次遍历，变量level记录当前节点所在层数，使用变量last标记每一层最后一个节点，每次出队时和last进行比较，相等则层数加1，并让last指向下一层。

func levelOrder(root *TreeNode) [][]int {
    // h=height(root)
    if root==nil{
        return nil
    }
    var a [][]int
    var q []*TreeNode
   
    front:=-1
    rear:=0
    level:=0
    last:=0
    
    q=append(q,root)
    for front<rear{
        t:=[]int{}
        for front<rear&&front<last{
            front++
            p:=q[front]
            t=append(t,p.Val)     
            if p.Left!=nil{
                rear++
                q=append(q,p.Left)
            
            }
            if p.Right!=nil{
                rear++
                q=append(q,p.Right)
            
            }
            
         }
         if front==last{
                level++
                last=rear
                a=append(a,t)
        }
        //  fmt.Println(a)
    }
    return a
    
}