前端算法系列-二叉树01

前序遍历

var preorderTraversal = function(root) {
    let res = []
    let frontFn = (root) => {
        // 节点为空时返回
        if(!root) return
        res.push(root.val)
        frontFn(root.left)
        frontFn(root.right)
        return
    }
    frontFn(root)
    return res
};

后序遍历

var postorderTraversal = function(root) {
    let res = []
    let endFn = (root) => {
        if(!root) return
        endFn(root.left)
        endFn(root.right)
        res.push(root.val)
        return
    }
    endFn(root)
    return res
};

中序遍历

var inorderTraversal = function(root) {
    let result = []
    let midFn = (root) =>{
        if(!root) return
        midFn(root.left)
        result.push(root.val)
        midFn(root.right)
        return
    }
    midFn(root)
    return result
};

前序遍历-迭代

// 迭代方法
var preorderTraversal = function(root) {
    let stack = root ? [root] : []
    let res = []
    while(stack.length > 0){
        let node = stack.pop()
        res.push(node.val)
        if(node.right) stack.push(node.right)
        if(node.left) stack.push(node.left)
    }
    return res
};

中序遍历-迭代

var inorderTraversal = function(root) {
    let cur = root
    let res = []
    let stack = []
    while(cur || stack.length > 0){
        if(cur){
            stack.push(cur)
            cur = cur.left
        }else{
            cur = stack.pop()
            res.push(cur.val)
            cur = cur.right
        }
    }
    return res
}

后序遍历-迭代

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

层序遍历

要利用队列先进先出的特点，相当于在进行广度搜索

var levelOrder = function(root) {
    let quee = root ? [root] : []
    let res = []

    while(quee.length > 0){
        let arr = []
        let size = quee.length
        for(let i=0;i<size;i++){
            let node = quee.shift()
            arr.push(node.val)
            if(node.left) quee.push(node.left)
            if(node.right) quee.push(node.right)
        }
        res.push(arr)
    }
    return res
};

107. 二叉树的层序遍历 II

var levelOrderBottom = function(root) {
    let quee = root ? [root] : []
    let res = []
    while(quee.length > 0){
        let size = quee.length
        let arr = []
        for(let i=0;i<size;i++){
            let node = quee.shift()
            if(node.left) quee.push(node.left)
            if(node.right) quee.push(node.right)
            arr.push(node.val)
        }
        res.unshift(arr)
    }
    return res
};

199. 二叉树的右视图

var rightSideView = function(root) {
    let quee = root ? [root] : []
    let res = []
    while(quee.length > 0){
        let arr = []
        let size = quee.length
        for(let i=0;i<size;i++){
            let node = quee.shift()
            if(i === (size - 1)){
                arr.push(node.val)
            }

            if(node.left){
                quee.push(node.left)
            }
            if(node.right){
                quee.push(node.right)
            }
        }
        res.push(arr)
    }
    return res
};

637. 二叉树的层平均值

var averageOfLevels = function(root) {
    let quee = root ? [root] : []
    let res = []
    while(quee.length > 0){
        let count = 0
        let size = quee.length
        for(let i=0;i<size;i++){
            let node = quee.shift()
            count += node.val
            if(node.left) quee.push(node.left)
            if(node.right) quee.push(node.right)
        }
        res.push(count/size)
    }
    return res
};

429. N 叉树的层序遍历

var levelOrder = function(root) {
    //每一层可能有2个以上,所以不再使用node.left node.right
    let res = []
    let queue = root ?  [root] : []
    while(queue.length > 0){
        let arr = []
        let size = queue.length
        for(let i=0;i<size;i++){
            let node = queue.shift()
            arr.push(node.val)
            if(node.children && node.children.length > 0){
                for(let j=0;j<node.children.length;j++){
                    queue.push(node.children[j])
                }
            }
        }
        res.push(arr)
    }
    

    return res;
};

515. 在每个树行中找最大值

var largestValues = function(root) {
    let res = []
    let queue = root ?  [root] : []
    while(queue.length > 0){
        let num = -Infinity
        let size = queue.length
        for(let i=0;i<size;i++){
            let node = queue.shift()
            num = node.val > num ? node.val : num
            if(node.left) queue.push(node.left)
            if(node.right) queue.push(node.right)
        }
        res.push(num)
    }
    return res
};

116. 填充每个节点的下一个右侧节点指针

var connect = function(root) {
    let res = []
    let queue = root ? [root] : []
    while(queue.length > 0){
        let size = queue.length
        for(let i=0;i<size;i++){
            let node = queue.shift()
            node.next = i === (size - 1) ? null : queue[0]
            if(node.left) queue.push(node.left)
            if(node.right) queue.push(node.right)
        }

    }
    return root
};

117. 填充每个节点的下一个右侧节点指针 II

var connect = function(root) {
    let res = []
    let queue = root ? [root] : []
    while(queue.length > 0){
        let size = queue.length
        for(let i=0;i<size;i++){
            let node = queue.shift()
            node.next = i === (size - 1) ? null : queue[0]
            if(node.left) queue.push(node.left)
            if(node.right) queue.push(node.right)
        }

    }
    return root
};

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
};

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
};