GO算法-树-全部打倒

二分搜索树:学习于：搞定大厂算法面试之leetcode精讲，自己只为记录

二分搜索树（英语：Binary Search Tree），也称为 有序二叉树或排序二叉树。满足以下几个条件：

• 若它的左子树不为空，左子树上所有节点的值都小于它的根节点。
• 若它的右子树不为空，右子树上所有的节点的值都大于它的根节点。
• 它的左、右子树也都是二分搜索树。

144，94，145

 一：树的前序中序后序遍历

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func preorderTraversal(root *TreeNode) []int {
    /**
    思路分析：
    前序遍历：根-左-右
    **/

    //开始

    res := []int{}
    var digui func(*TreeNode)
    digui = func (node *TreeNode) {
        if node == nil {
            return
        }
        //根左右
        res = append(res, node.Val)
        digui(node.Left)
        digui(node.Right)
    }

    digui(root)

    return res 
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func inorderTraversal(root *TreeNode) []int {
    /**
    思路分析：
    前中后，指的是根的位置
    前序遍历：根-》左-》右
    中序遍历：左-》根-》右
    后序遍历：左-》右-》根
    **/

    //开始

    res := []int{}
    var digui func(*TreeNode)
    digui = func(node *TreeNode){
        if node == nil {
            return
        }
        //左根右
        digui(node.Left)
        res = append(res, node.Val)
        digui(node.Right)
    }
    digui(root)

    return res
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    /**
    思路分析：
    后序遍历：左-》右-》根
    **/

    //开始

    res := []int{}
    var digui func(*TreeNode)
    digui = func(node *TreeNode) {
        if node == nil {
            return
        }

        digui(node.Left)
        digui(node.Right)
        res = append(res, node.Val)
    }
    digui(root)

    return res
}

二：验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
 

示例 1：

输入：root = [2,1,3]
输出：true
示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isValidBST(root *TreeNode) bool {
    /**
    思路分析：
    验证的话，采用中序遍历，左根右，这样遍历出来的就是一个递增的树
    **/

    res := []int{}
    var digui func(*TreeNode)
    digui = func(node *TreeNode) {
        if node != nil {
            //根节点的值
            digui(node.Left)
            res = append(res, node.Val)
            digui(node.Right)
        }
    }
    
    digui(root)

    for i:=0; i < len(res); i++ {
        if i > 0 && res[i] <= res[i-1] {
            return false
        }
    }

    return true
}

三：二叉树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。
示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val   int
 *     Left  *TreeNode
 *     Right *TreeNode
 * }
 */

func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
    /**
    思路分析：
    遍历节点，如果都比p和q大，在其右侧，反之左侧，一大一小就是分叉点，就是返回的值
    **/

    max := p.Val
    min := q.Val
    if max < min {
        tmp := max
        max = min
        min = tmp
    }

    tree := root
    for {
        if tree.Val > max {
            //当前节点在右侧，所以左走
            tree = tree.Left
        } else if tree .Val < min {
            tree = tree.Right
        } else {
            return tree
        }
    }
}

四：二叉树的层序遍历（102）

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：
二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层序遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    /**
    思路分析：
    bfs遍历，第一层循环的终止条件是节点还有值，用i记录层数
    第二层遍历是遍历这一层的所有节点
    **/

    //开始
    ret := [][]int{}
    q := []*TreeNode{root}

    //判断下根节点是不是为空
    if root == nil {
        return ret
    }

    //第i层有节点，就遍历
    for i:=0; len(q) > 0; i++ {
        //这里需要初始化下
        ret = append(ret, []int{})

        n := len(q)
        //这里是把这层的左右节点都存进来
        p := []*TreeNode{}
        for j:=0; j<n; j++ {
            //依次存节点值
            ret[i] = append(ret[i], q[j].Val)

            //存左右节点
            if q[j].Left != nil {
                p = append(p, q[j].Left)
            }

            if q[j].Right != nil {
                p = append(p, q[j].Right)
            }
        }

        q = p
    }

    return ret
}

五：二叉树的锯齿状层序遍历（103）

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func zigzagLevelOrder(root *TreeNode) [][]int {
    ans := [][]int{}

    if root == nil {
        return ans
    }

    queue := []*TreeNode{root}

    //可以直接是 len(queue)>0， 这里i是记录的层数，方便奇偶转向
    for i:=0; len(queue)>0; i++{
        res := []int{}
        q:=queue
        queue = nil

        for _,node := range q {
            res = append(res, node.Val)

            if node.Left != nil {
                queue = append(queue, node.Left)
            }

            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }

        if i%2 == 1 {
            for j, n := 0, len(res); j<n/2; j++{
                res[j], res[n-1-j] = res[n-1-j], res[j]
            }
        }
        ans = append(ans, res)
    }

    return ans
}

六：二叉树的公共祖先（236）

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
    /**
    思路分析：
    二叉树是不保证左边一定小于根节点的，
    二叉搜索树是，所以二叉搜索树的公共祖先可以利用比较左右判断，但是二叉树不可以

    3种情况1：根节点（本身相等） 2：根节点的左右各自包含 3：在根节点的左右某一节点
    **/

    if root == nil {
        return root
    }

    if root.Val == p.Val || root.Val == q.Val {
        return root
    }

    leftHave := lowestCommonAncestor(root.Left, p, q)
    rightHave := lowestCommonAncestor(root.Right, p, q)

    if leftHave != nil && rightHave != nil {
        return root
    }

    if leftHave == nil {
        return rightHave
    }

    return leftHave
}