算法练习day13

一、层序遍历

/**
 * 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 {number[][]}
 */
var levelOrder = function(root) {
    if(!root) {
        return []
    }
    let result = []
    let queue = [root]
    while(queue.length) {
        let level = []
        let len = queue.length
        for(let i = 0; i < len;i++) {
            let node = queue.shift()
            level.push(node.val)
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
        result.push(level)
    }
    return result
};

二叉树的层序遍历2

var levelOrderBottom = function (root) {
    if (!root) {
        return []
    }
    let result = []
    let queue = [root]
    while (queue.length) {
        let level = []
        let len = queue.length
        for (let i = 0; i < len; i++) {
            let node = queue.shift()
            level.push(node.val)
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
        result.unshift(level)
    }
    return result
};

二叉树的右视图

var rightSideView = function(root) {
     if(!root) {
        return []
    }
    let result = []
    let queue = [root]
    while(queue.length) {
        let len = queue.length
        for(let i = 0; i < len;i++) {
            let node = queue.shift()
            if(i === len - 1) {
                result.push(node.val)
            }
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
    }
    return result
};

二叉树的层平均值

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var averageOfLevels = function(root) {
    if(!root) {
        []
    }
    let queue = [root]
    let result = []
    while(queue.length) {
        let sum = 0
        let len = queue.length
        for(let i = 0; i < len; i++) {
            let node = queue.shift()
            sum += node.val
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
        result.push(sum / len)
    }
    return result
};

N叉数的层序遍历

/**
 * // Definition for a Node.
 * function Node(val,children) {
 *    this.val = val;
 *    this.children = children;
 * };
 */

/**
 * @param {Node|null} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
    if(!root) {
        return []
    }
    let result = []
    let queue = [root]
    while(queue.length) {
        let level = []
        let len = queue.length
        for(let i = 0; i < len;i++) {
            let node = queue.shift()
            level.push(node.val)
            for(let j of node.children) {
                j && queue.push(j)
            }
        }
        result.push(level)
    }
    return result
};

在每个树行中找最大值

/**
 * 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 {number[]}
 */
var largestValues = function (root) {
    if(!root) {
        return []
    }
    let result = []
    let queue = [root]
    while(queue.length) {
        let max = -Infinity
        let len = queue.length
        for(let i = 0; i < len;i++) {
            let node = queue.shift()
            max = Math.max(max, node.val)
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
        result.push(max)
    }
    return result
};

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

/**
 * // Definition for a Node.
 * function Node(val, left, right, next) {
 *    this.val = val === undefined ? null : val;
 *    this.left = left === undefined ? null : left;
 *    this.right = right === undefined ? null : right;
 *    this.next = next === undefined ? null : next;
 * };
 */

/**
 * @param {Node} root
 * @return {Node}
 */
var connect = function(root) {
    if(!root) {
        return root
    }
    let queue = [root]
    while(queue.length) {
        let len = queue.length
        for(let i = 0; i < len;i++) {
            let node = queue.shift()
            if(i < len - 1) {
                node.next = queue[0]
            }
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
    }
    return root
};

二叉树的最大深度

/**
 * 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 {number}
 */
var maxDepth = function (root) {
    if (!root) {
        return 0
    }
    let queue = [root]
    let maxHeight = 0
    while (queue.length) {
        let len = queue.length
        maxHeight++;
        for (let i = 0; i < len; i++) {
            let node = queue.shift()
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
    }
    return maxHeight
}

二叉树的最小深度

/**
 * 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 {number}
 */
var minDepth = function(root) {
    if (!root) {
        return 0
    }
    let queue = [root]
    let minHeight = 0
    while (queue.length) {
        let len = queue.length
        minHeight++;
        for (let i = 0; i < len; i++) {
            let node = queue.shift()
            if(!node.left && !node.right) {
                return minHeight
            }
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
    }
    return minHeight
};

二、翻转二叉树

把每个节点都左右翻转即可

递归法，后序遍历

/**
 * 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 {TreeNode}
 */
var invertTree = function(root) {
    if(!root) {
        return root
    }
    let left = invertTree(root.left)
    let right = invertTree(root.right)
    root.left = right
    root.right = left
    return root
};

迭代法

var invertTree = function(root) {
    if(!root) {
        return root
    }
    let stack = [root]
    while(stack.length) {
        let node = stack.pop()
        if(node === null) {
            let node = stack.pop()
            invertNode(node, node.left, node.right)
        } else {
            node.right && stack.push(node.right)
            node.left && stack.push(node.left)
            stack.push(node)
            stack.push(null)
        }
    }
    return root
};

function invertNode(node, left, right) {
    node.right = left
    node.left = right
}

层序遍历

var invertTree = function (root) {
    if (!root) {
        return root
    }
    let queue = [root]
    while (queue.length) {
        let len = queue.length
        for (let i = 0; i < len; i++) {
            let node = queue.pop()
            invertNode(node, node.left, node.right)
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
    }
    return root
};

function invertNode(node, left, right) {
    node.right = left
    node.left = right
}

三、对称二叉树

递归法需用后序遍历，迭代法需要注意左右节点的入队顺序

递归实现

/**
 * 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 isSymmetric = function(root) {
    return check(root.left, root.right)
};

function check(left, right) {
    if((left && !right) || (!left && right)) {
        return false
    } else if (!left && !right) {
        return true
    } else if(left.val !== right.val) {
        return false
    }
    return check(left.left, right.right) && check(left.right, right.left)
}

队列实现

/**
 * 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 isSymmetric = function(root) {
    let queue = [root.left, root.right]
    while(queue.length) {
        let leftNode = queue.shift()
        let rightNode = queue.shift()
        if(!leftNode && !rightNode) {
            continue
        }
        if(!leftNode || !rightNode || leftNode.val !== rightNode.val) {
            return false
        }
        queue.push(leftNode.left)
        queue.push(rightNode.right)
        queue.push(leftNode.right)
        queue.push(rightNode.left)
    }
    return true
};