动态算法（基础九）笔记回顾

1、二叉树的最大深度

示例 1：

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

输入：root = [1,null,2]
输出：2

var maxDepth = function(root) {
    if(!root) {
        return 0;                        //到根节点就返回
    } else {                             //递归一次，就会使得栈的计数加一
        const left = maxDepth(root.left);//递归左子树
        const right = maxDepth(root.right);//递归右子树
        return Math.max(left, right) + 1;//1加左节点和有节点深度的较大者
    }
};

2、验证二叉搜索树

示例 1：

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

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

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isValidBST = function(root) {
                                                           // 利用中序遍历有序的性质
    let checkArr = []                                      // 辅助数组
                                                           // traverse: 递归遍历树的模板函数
    let traverse = function(root) {
        if(root == null)                                   //根节点返回
            return
                                                           // 使用中序遍历（左根右）
        traverse(root.left)                                
        checkArr.push(root.val)
        traverse(root.right)

    }
    traverse(root)
                                                           // 遍历数组，比较是否有序
    for(let i = 1;i= checkArr[i])                   //如果不是有序的返回false
            return false
    }
    return true
};

3、对称二叉树

示例 1：

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

输入：root = [1,2,2,null,3,null,3]
输出：false

var isSymmetric = function(root) {
                                                        // 参数和返回值
    const compare = (left, right) => {
                                                        // 终止条件
        if(left && !right) return false                 //有左子无右子返回false
        else if (!left && right) return false           //有右子无 左子返回false
        else if (!left && !right) return true           //无左右子说明对称返回true
        else if (left.val !== right.val) return false   
                                                        // 其他都是左右孩子不为空，并且值相等的情况

                                                        // 本层递归的逻辑
                                                        // 遍历顺序：后序，左右中
        return compare(left.left, right.right) && compare(right.left, left.right)//左子的左值和右子的右值，和左子的右值和右子的左值进行对比，只有两个全相等才返回true
    }

    return compare(root.left, root.right)               //将整个树的左右分别放入进行对比
};

4、二叉树的层序遍历

示例 1：

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

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

输入：root = []
输出：[]

var levelOrder = function(root) {
                                            // 创建一个 Map 对象 m，用于存储每层的节点值
    let m = new Map();
    let count = 0;                          //定义初始值（层数）

                                            // 定义一个递归函数 fn，用于遍历二叉树节点
    var fn = (root, count) => {
                                            // 如果当前节点为空，直接返回
        if (!root) return;
        
                                            // 如果 Map 对象中不存在当前层的记录，就在 Map 对象中新增一个数组，用于存储当前层的节点值
        if (!m.has(count)) {
            m.set(count, [root.val]);
        } else {
                                           // 如果当前层的记录已经存在，则直接将当前节点的值存入对应的数组中
            m.get(count).push(root.val);
        }

        count++;                           // 计数器加一，用于记录当前层的层数
        fn(root.left, count);              // 递归遍历左子节点
        fn(root.right, count);             // 递归遍历右子节点
    }

                                           // 调用递归函数 fn，开始遍历二叉树
    fn(root, count);

                                           // 使用解构赋值将 Map 中的值转换为数组，并返回
    return [...m.values()];
};

5、将有序数组转换为二叉搜索树

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3]
输出：[3,1]
解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {number[]} nums
 * @return {TreeNode}
 */
	var sortedArrayToBST = function (nums) {
	  if (!nums.length) {                        //长度为空，返回null
	    return null
	  }
	
	                                            // 二叉搜索树的中序遍历，就是升序列表
	                                            // 以升序数组的中间元素作为根节点 root
	  const mid = Math.floor(nums.length / 2)   //找出中间值
	  const root = new TreeNode(nums[mid])      //创建新树
	
	  root.left = sortedArrayToBST(nums.slice(0, mid))   //截取左半树，再进行递归，再找中间值递归左树
	  root.right = sortedArrayToBST(nums.slice(mid + 1)) //截取右半树，再进行递归，再找中间值递归右树
	
	  return root                                         //返回root
};