513. 找树左下角的值

function findBottomLeftValue(root: TreeNode | null): number {
    let res = 0;
    let queue = [root];
    while (queue.length) {
        const length = queue.length;
        let curRes = [];
        for (let i = 0; i < length; i++) {
            const node = queue.shift();
            curRes.push(node.val);
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
        };
        res = curRes[0];
    }
    return res;
};

112. 路径总和

function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
    if (root === null) {
        return false;
    }
    let res = [];
    const getSum = (node: TreeNode | null, curSum: number) => {
        if (node.left === null && node.right === null) {
            curSum += node.val;
            res.push(curSum);
            return;
        };
        curSum += node.val;
        node.left && getSum(node.left, curSum);
        node.right && getSum(node.right, curSum);
    };
    getSum(root, 0);
    return res.includes(targetSum);
};

113. 路径总和 ii

function pathSum(root: TreeNode | null, targetSum: number): number[][] {
    let res = [];
    const dfs = (node: TreeNode | null, curSum: number, curPath: number[]) => {
        if (node === null) {
        return;
        }
        curSum += node.val;
        curPath.push(node.val);
        if (node.left === null && node.right === null) {
            if (curSum === targetSum) {
                res.push([...curPath]);
            }
            curPath.pop();
            return;
        };
        dfs(node.left, curSum, curPath);
        dfs(node.right, curSum, curPath);
        curPath.pop();
    };
    dfs(root, 0, []);
    return res;
};

106. 从中序与后序遍历序列构造二叉树

function buildTree(inorder: number[], postorder: number[]): TreeNode | null {
    if (!inorder.length) {
        return null;
    }
    let treeMid = postorder.pop();
    let treeMidIndex = inorder.indexOf(treeMid);
    const Tree = new TreeNode(treeMid);

    Tree.left = buildTree(inorder.slice(0, treeMidIndex), postorder.slice(0, treeMidIndex));

    Tree.right = buildTree(inorder.slice(treeMidIndex + 1), postorder.slice(treeMidIndex));

    return Tree;
};

105. 从前序与中序遍历序列构造二叉树

function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
    if (!preorder.length) {
        return null;
    };

    let rootVal = preorder[0];
    let rootValIndex = inorder.indexOf(rootVal);
    const Tree = new TreeNode(rootVal);

    Tree.left = buildTree(preorder.slice(1, rootValIndex + 1), inorder.slice(0, rootValIndex));

    Tree.right = buildTree(preorder.slice(rootValIndex + 1), inorder.slice(rootValIndex + 1));

    return Tree;
};