1、

2、leetcode 374 猜数字大小 分而治之解法

• 使用这种解法 利用小问题的结果 解决大问题

//时间复杂度 每次缩小一半 O(logN)  空间复杂度  递归堆栈 O(logN)
//典型的二分搜索法
var guessNumber = function(n) {
    var rec = (low,high) =>  {
        //递归结束条件
        if(low > high) {return}
        var mid = Math.floor((low + high)/2)
        var res = guess(mid)
        if(res === 0){return mid}
        else if(res === -1){return rec(1,mid - 1)}
        else {return rec(mid + 1,high)}
    }
    return rec(1,n)
};

3、leetcode 226 翻转二叉树

• 比我们想象中的简单

// 时间复杂度 O(n) n表示树所有节点
// 空间复杂度 O(h) h表示树的高度 最坏情况下 n 往一边排 另一边没有
var invertTree = function(root) {
    //递归结束条件 
    if(!root){return null}
return {
    //递归翻转 左右子树
    val : root.val,
    left : invertTree(root.right),
    right : invertTree(root.left)

}
};

4、 LeetCode：100. 相同的树

// 时间复杂度 O(n) n就是二叉树节点树
// 空间复杂度 O(h) h表示二叉树高度 最坏情况下 O(n)  二叉树均匀分布情况下 O(logn)
var isSameTree = function(p, q) {
    //如果都为空 结果为 true
    if(!p && !q){return true}
    // 根节点相同   左子树相同  右子树相同 返回 true 否则返回 false
    if(p && q && p.val == q.val && isSameTree(p.left,q.left) && 
    isSameTree(p.right,q.right)){
        return true
    }
    return false
};

5、Leetcode 101 对称二叉树

// 时间复杂度 O(n) 空间复杂度 O(n) n表示树的高度 均匀分布情况下O(logn) 
var isSymmetric = function(root) {
    if(!root){return true}
    var isMirror = (l,r)=>{
        // 递归条件
        if(!l && !r){return true}
        // 根节点一致  左节点右节点为镜像节点
        if(l && r && l.val === r.val && isMirror(l.left,r.right) && isMirror(l.right,r.left)){
            return true
        }
        return false
    }
    return isMirror(root.left,root.right)
};

6、小结