110. 平衡二叉树

题目：

给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为：

一个二叉树_每个节点_ 的左右两个子树的高度差的绝对值不超过 1 。

思路：

没想出来

优化：

递归：先写一个函数，用来获取节点的高度，然后递归调用，传入一个节点的左右子节点，如果某个节点返回的参数是-1，说明这个树中存在不平衡节点，直接返回-1，如果左右节点返回正常，那么对节点的高度差进行判断，大于1返回-1，在主函数直接返回放入根节点的获取高度函数值是否为-1的结果，如果是，返回false，不是返回true

迭代：先写一个函数，利用栈，获取每个节点的高度，如果高度小于-1直接置0，返回最后结果，在主函数中利用栈，比较左右两个节点的高度差，如果大于1返回false，否则执行完毕返回true

代码：

/**
 * 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 isBalanced = function(root) {
    return !(getHeight(root)===-1)
};

const getHeight = (node) => {
    if (!node) return 0
    let leftHeight = getHeight(node.left)
    if (leftHeight===-1) return -1
    let rightHeight = getHeight(node.right)
    if (rightHeight===-1) return -1

    let res
    if (Math.abs(leftHeight-rightHeight)>1) {
        res = -1
    }else {
        res = 1+Math.max(leftHeight,rightHeight)
    }
    return res
}

// 迭代
var isBalanced = function(root) {
    if (!root) return true
    const stack = [root]
    while (stack.length) {
        const node = stack.pop()
        if (Math.abs(getHeight(node.left)-getHeight(node.right))>1) {
            return false
        }

        node.right&&stack.push(node.right)
        node.left&&stack.push(node.left)
    }
    return true
};

const getHeight = (cur) => {
    const stack = []
    if (cur) stack.push(cur)
    let depth = 0,res = 0
    while (stack.length) {
        let node = stack.pop()
        if (node) {
            stack.push(node)
            stack.push(null)
            depth++
            node.right&&stack.push(node.right)
            node.left&&stack.push(node.left)
        }else {
            node = stack.pop()
            depth--
        }
    res = res>depth?res:depth
    }
    return res
}

总结：

这道题不难，但是具体逻辑有点不好想

257. 二叉树的所有路径

题目：

给你一个二叉树的根节点 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 {string[]}
 */
var binaryTreePaths = function(root) {
    let res=[],path = []
    if (!root) return res
    traversal(root,path,res)
    return res
};

const traversal = (cur,path,res) => {
    path.push(cur.val)
    if (!cur.left&&!cur.right) {
        res.push(path.join('->'))
        return;
    }
    if (cur.left) {
        traversal(cur.left,path,res)
        path.pop()
    }
    if (cur.right) {
        traversal(cur.right,path,res)
        path.pop()
    }
}

总结：

第一次接触递归，有点难理解

404. 左叶子之和

题目：

给定二叉树的根节点 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 sumOfLeftLeaves = function(root) {
    if (!root) return 0
    if (!root.left&&!root.right) return 0

    let leftval = sumOfLeftLeaves(root.left)
    if (root.left&&!root.left.left&&!root.left.right) {
        leftval = root.left.val
    }
    let rightval = sumOfLeftLeaves(root.right)

    return leftval+rightval
};

总结：

感觉有点难

Day17总结

今天入职第一天，感觉好累，回来没精力去看完整的写法，回头补吧