前端算法系列-二叉树02

226. 翻转二叉树

很简单，前序遍历加翻转节点就行

var invertTree = function(root) {
    let reverseFn = (root) => {
        if(!root) return 
        [root.left,root.right] = [root.right,root.left ]
        reverseFn(root.left)
        reverseFn(root.right)
    }
    reverseFn(root)
    return root
};

也可以用迭代遍历

var invertTree = function(root) { 
    let stack = root ? [root] : []
    while(stack.length > 0){
        let node = stack.pop()
        let temp = node.left
        node.left = node.right
        node.right = temp
        if(node.left) stack.push(node.left)
        if(node.right) stack.push(node.right)
    }
    return root
}

101. 对称二叉树

第一遍是自己写的，没动脑子，还在思维惯性用遍历的方式写，代码较为冗余

var isSymmetric = function(root) {
    // 要递归两遍？
    let left = []
    let flag = true
    let fn1 = (root) => {
        if(!root) {
            left.push(null)
            return
        }
        left.push(root.val)
        fn1(root.left)
        fn1(root.right)
    }
    let fn2 = (root) => {
        let node = left.shift()
        if(node === undefined){
            flag = false
            return
        }else if(node !== (root ? root.val : root)){
            flag = false
            return
        }
        if(root){
            fn2(root.right)
            fn2(root.left)
        }
    }
    fn1(root.left)
    fn2(root.right)
    return flag && (left.length === 0)
};

使用递归比较的方法进行判断

let compare = (lNode,rNode) => {
    if(!lNode || !rNode){
        if(!lNode && !rNode){
            return true
        }else{
            return false
        }

    }
    return lNode.val === rNode.val && compare(lNode.left,rNode.right) && compare(lNode.right,rNode.left)
}
var isSymmetric = function(root) {
    return compare(root.left,root.right)
};

使用迭代队列比较的方法进行判断

var isSymmetric = function(root) {
    let queue = []
    if(root){
        queue = [root.left,root.right]
    }else{
        return false
    }
    while(queue.length > 1){
        let one = queue.shift()
        let two = queue.shift()
        if(one && two){
            if(one.val !== two.val) return false
            queue.push(one.left,two.right,one.right,two.left)
        }else if(one || two){
            return false
        }
    }
    return true
}

使用迭代栈的方法进行判断

var isSymmetric = function(root) {
    let stack = []
    if(root){
        queue = [root.left,root.right]
    }else{
        return false
    }
    while(queue.length > 1){
        let one = queue.pop()
        let two = queue.pop()
        if(one && two){
            if(one.val !== two.val) return false
            queue.push(one.left,two.right,one.right,two.left)
        }else if(one || two){
            return false
        }
    }
    return true
}

104. 二叉树的最大深度

这道题之前学习层序遍历的时候使用迭代法做过，今天再用递归法做一遍

// var maxDepth = function (root) {
//   // 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
//     let max = 0
//     let queue = root ? [root] : []
//     while(queue.length > 0){
//         let size = queue.length
//         for(let i=0;i<size;i++){
//             let node = queue.shift()
//             if(node.left) queue.push(node.left)
//             if(node.right) queue.push(node.right)
//         }
//         max++
//     }
//     return max
// };

var maxDepth = function(root){
    if(root === null) return 0
    return 1+Math.max(maxDepth(root.left) , maxDepth(root.right))
}

111. 二叉树的最小深度

这道题之前学习层序遍历的时候使用迭代法做过，今天再用递归法做一遍

这块要注意一下，最小深度是到最小叶子节点的高度，所以空的子树不算在内，代码逻辑里要做额外的判断区分

// var minDepth = function(root) {
//     let res = Infinity
//     let count = 0
//     let queue = root ? [root] : []
//     while(queue.length > 0){
//         let size = queue.length
//         let isYezi = false
//         for(let i=0;i<size;i++){
//             let node = queue.shift()
//             if(node.left) queue.push(node.left)
//             if(node.right) queue.push(node.right)
//             if(!node.left && !node.right){
//                 isYezi = true
//             }
//         }
//         count++
//         if(isYezi){
//             res = count < res ? count : res 
//             break
//         }
//     }
//     return res === Infinity ? 0 : res
// };

var minDepth = function(root){
    if(!root) return 0
    if(!root.left && root.right){
        return 1 + minDepth(root.right)
    }
    if(root.left && !root.right){
        return 1 + minDepth(root.left)
    }
    return 1 + Math.min(minDepth(root.left),minDepth(root.right))
}