二叉树

二叉树的前序遍历

递归法

func preorderTraversal(root *TreeNode) {
       res:=[]int{}
       preorderTraversal1(root,&res)
       return res
}
func preorderTraversal1(root *TreeNode,res *[]int){
     if root!=nil{
         res=append(res,root.val)
         preorderTraversal1(root.left,res)
         preorderTraversal1(root.right,res) 
     }
}

二叉树的中序遍历

递归法

func inorderTraversal(root *TreeNode){
      res:=[]int{}
      inorderTraversal1(root,res)
      return res
}
func inorderTraversal1(root *TreeNode,res *[]int){
      if root!=nil{
            inorderTraversal1(root.left,res)
            *res=append(*res,root.val)
            inorderTraversal1(root.right,res)
      }
}

二叉树的后序遍历

递归法

func  postorderTraversal(root *TreeNode){
     res:=[]int{}
     postorderTraversal(root,&res)
     return res
} 
func postorderTraversal1(root *TreeNode,res *[]int){
      if root!=nil{
          postorderTraversal1(root.left,res)
          postorderTraversal1(root.right,res)
          *res=append(*res,root.val)
      }
}

二叉树的层次遍历

从上到下打印二叉树

二叉树的最大深度

剑指offer55-1
输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。
例如：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。
分析:如果一棵树只有一个 结点，它的深度为1。如果根结点只有左子树而没有右子树，那么树的 深度应该是其左子树的深度加1；同样如果根结点只有右子树而没有左 子树，那么树的深度应该是其右子树的深度加1。如果既有右子树又有 左子树，那该树的深度就是其左、右子树深度的较大值再加1。

func maxDepth(root *TreeNode) int {
    if root == nil {
		return 0
	}
	maxLeftTree := maxDepth(root.Left)
	maxRightTree := maxDepth(root.Right)

	return int(math.Max(float64(maxLeftTree), float64(maxRightTree))) + 1
}

从前序中序遍历重建二叉树
二叉树的增删改查
二叉树搜索树的第k大节点
验证二叉搜索树
二叉搜索树的后续遍历
恢复二叉搜索树
对称二叉树

判断是不是平衡二叉树

leetcode 面试题55 - II. 平衡二叉树
输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]
3
/
9 20
/
15 7
返回 true 。
分析:用后序遍历的方式遍历整棵二叉树。在遍历 某结点的左右子结点之后，我们可以根据它的左右子结点的深度判断它是不是平衡的，并得到当前结点的深度。当最后遍历到树的根结点的时 候，也就判断了整棵二叉树是不是平衡二叉树。

面试题34. 二叉树中和为某一值的路径

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
示例:
给定如下二叉树，以及目标和 sum = 22，
5
/
4 8
/ /
11 13 4
/ \ /
7 2 5 1

面试题26. 树的子结构

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。
例如:
给定的树 A:
3
/
4 5
/
1 2
给定的树 B：
4
/
1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。
示例 1：
输入：A = [1,2,3], B = [3,1]
输出：false
https://leetcode-cn.com/problems/shu-de-zi-jie-gou-lcof/solution/mian-shi-ti-26-shu-de-zi-jie-gou-xian-xu-bian-li-p/

func isSubStructure(A *TreeNode, B *TreeNode) bool {
	return (A != nil && B != nil) && (recur(A, B) || isSubStructure(A.Left, B) || isSubStructure(A.Right, B))
}

func recur(A *TreeNode, B *TreeNode) bool {
	if B == nil {
		return true
	}
	if A == nil || A.Val != B.Val {
		return false
	}
	return recur(A.Left, B.Left) && recur(A.Right, B.Right)
}

面试题27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。
例如输入：
4
/
2 7
/ \ /
1 3 6 9
镜像输出：
4
/
7 2
/ \ /
9 6 3 1
示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

func mirrorTree(root *TreeNode) *TreeNode {
	if root == nil {
		return nil
	}
	tmp := root.Left
	root.Left = mirrorTree(root.Right)
	root.Right = mirrorTree(tmp)
	return root
}

面试题28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/
2 2
/ \ /
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/
2 2
\
3 3
示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true

面试题33 二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。
参考以下这颗二叉搜索树：
5
/
2 6
/
1 3
示例 1：

输入: [1,6,3,2,5]
输出: false
示例 2：

输入: [1,3,2,6,5]
输出: true

func verifyPostorder(postorder []int) bool {
	return helper1(postorder, 0, len(postorder)-1)
}

//13265   root 5 right 6 左子树小于root,右子树大于root
func helper1(postorder []int, i, j int) bool {
	if i >= j {
		return true
	}
	p := i
	for postorder[p] < postorder[j] {
		p++
	}
	m := p //为第一个大于root的值，其后为右子树
	for postorder[p] > postorder[j] {
		p++
	}
	return p == j && helper1(postorder, i, m-1) && helper1(postorder, m, j-1)
}