代码随想录第16天 | 513.找树左下角的值 112. 路径总和 113.路径总和ii 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

513.找树左下角的值

/**
 * 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 findBottomLeftValue = function(root) {
    let queue=[root] //队列
    let x=0

    while(queue.length!==0){//当queue里有数时
        let temp=[]    //这一维数组
        let size=queue.length
        while(size!==0){ //把此层弹出，并把他们的儿子多少个，并入队
        	let n = queue.shift() //弹出头部
        	temp.push(n.val)  //此层弹入
            if(n.left)    queue.push(n.left)    //下一层计数            
            if(n.right)   queue.push(n.right) 
            size--
        }
        x=temp[0]//queue里面没数时
    }
    return x
};

卡哥的递归

var findBottomLeftValue = function(root) {
    //首先考虑递归遍历 前序遍历 找到最大深度的叶子节点即可
    let maxPath = 0, resNode = null;
    // 1. 确定递归函数的函数参数
    const dfsTree = function(node, curPath) {
    // 2. 确定递归函数终止条件
        if(node.left === null && node.right === null) {
            if(curPath > maxPath) {  //实现左下的第一个，如果有等于（右下）
            maxPath = curPath;
            resNode = node.val;
            }
        }
        node.left && dfsTree(node.left, curPath+1);
        node.right && dfsTree(node.right, curPath+1);
    }
    dfsTree(root,1);
    return resNode;
};

第一想法

层序

112. 路径总和

/**
 * 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
 * @param {number} targetSum
 * @return {boolean}
 */
var hasPathSum = function(root, targetSum) {
    let flag=false;
    var path = function(node,count){
     if(!node) return 0
       count+=node.val
      //2. 确定终止条件，到叶子节点就终止
       if(node.left===null&&node.right===null){
           if(count===targetSum){
             flag=true
           }
            return
       }
       node.left&&path(node.left,count);
       node.right&&path(node.right,count);
  }
   path(root,0)
   return flag
};

第一想法

跟257. 二叉树的所有路径很像

困难

count+=node.val我在 if(node.left== null&&node.right ===null)这里面又加了一遍

收获

• 回溯和递归差不多，但是回溯（在子节点判断）要传输参数，此题就是count。递归是在root上判断

---

113.路径总和

/**
 * 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
 * @param {number} targetSum
 * @return {number[][]}
 */
var pathSum = function(root, targetSum) {
     let res=[]
     if(!root) return res
    var path = function(node,count,curPath){
     
       count+=node.val
        
      //2. 确定终止条件，到叶子节点就终止
       if(node.left===null&&node.right===null){
           if(count===targetSum){
               curPath+=node.val;
               res.push(curPath.split(','));
           }
            return
       }
       curPath+=node.val+','
       node.left&&path(node.left,count,curPath);
       node.right&&path(node.right,count,curPath);
  }
   path(root,0,'')
   return res
};

第一想法

112和257的结合，只不过把结果的字符串转为数组

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

/**
 * 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 {number[]} inorder
 * @param {number[]} postorder
 * @return {TreeNode}
 */
var buildTree = function(inorder, postorder) {
 if (!inorder.length) return null;
    const rootVal = postorder.pop(); // 从后序遍历的数组中获取中间节点的值， 即数组最后一个值
    let rootIndex = inorder.indexOf(rootVal); // 获取中间节点在中序遍历中的下标
    const root = new TreeNode(rootVal); // 创建中间节点
    root.left = buildTree(inorder.slice(0, rootIndex), postorder.slice(0, rootIndex)); // 创建左节点
    root.right = buildTree(inorder.slice(rootIndex + 1), postorder.slice(rootIndex)); // 创建右节点
    return root;
};

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

/**
 * 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 {number[]} preorder
 * @param {number[]} inorder
 * @return {TreeNode}
 */
var buildTree = function(preorder, inorder) {
 if (!inorder.length) return null;
    const rootVal = preorder.shift(); // 从先序遍历的数组中获取中间节点的值， 即数组第一个一个值
    let rootIndex = inorder.indexOf(rootVal); // 获取中间节点在中序遍历中的下标
    const root = new TreeNode(rootVal); // 创建中间节点
    root.left = buildTree(preorder.slice(0, rootIndex), inorder.slice(0, rootIndex)); // 创建左节点
    root.right = buildTree(preorder.slice(rootIndex), inorder.slice(rootIndex+1)); // 创建右节点
    return root;
};

第一想法

知道用递归，知道用分割，不知道返回值是root，以为是数组