Merge pull request #911 from Tiffany-yuan/master

update: 110.平衡二叉树js版本格式化 && 112. 路径总和  路径总和-ii js迭代法

problems/0110.平衡二叉树.md

@@ -607,29 +607,23 @@ func abs(a int)int{
 ## JavaScript 
 ```javascript
 var isBalanced = function(root) {
-    //还是用递归三部曲  + 后序遍历 左右中 当前左子树右子树高度相差大于1就返回-1
+    //还是用递归三部曲 + 后序遍历 左右中 当前左子树右子树高度相差大于1就返回-1
     // 1. 确定递归函数参数以及返回值
-    const getDepth=function(node){
+    const getDepth = function(node) {
-    // 2. 确定递归函数终止条件
+        // 2. 确定递归函数终止条件
-        if(node===null){
+        if(node === null) return 0;
-            return 0;
+        // 3. 确定单层递归逻辑
+        let leftDepth = getDepth(node.left); //左子树高度
+        let rightDepth = getDepth(node.right); //右子树高度
+        if(leftDepth === -1) return -1;
+        if(rightDepth === -1) return -1;
+        if(Math.abs(leftDepth - rightDepth) > 1) {
+            return -1;
+        } else {
+            return 1 + Math.max(leftDepth, rightDepth);
         }
-    // 3. 确定单层递归逻辑
-    let leftDepth=getDepth(node.left);//左子树高度
-    if(leftDepth===-1){
-        return -1;
     }
-    let rightDepth=getDepth(node.right);//右子树高度
+    return !(getDepth(root) === -1);
-    if(rightDepth===-1){
-        return -1;
-    }
-    if(Math.abs(leftDepth-rightDepth)>1){
-        return -1;
-    }else{
-        return 1+Math.max(leftDepth,rightDepth);
-    }
-    }
-    return getDepth(root)===-1?false:true;
 };
 ```
 

problems/0112.路径总和.md

@@ -614,6 +614,7 @@ func haspathsum(root *treenode,sumnodes *[]int,targetsum int,result *[][]int){
 
 0112.路径总和
 
+**递归**
 ```javascript
 /**
  * @param {treenode} root
@@ -643,9 +644,38 @@ let haspathsum = function (root, targetsum) {
   // return haspathsum(root.left, targetsum - root.val) || haspathsum(root.right, targetsum - root.val);
 };
 ```
+**迭代**
+```javascript
+let hasPathSum = function(root, targetSum) {
+    if(root === null) return false;
+    let nodeArr = [root];
+    let valArr = [0];
+    while(nodeArr.length) {
+        let curNode = nodeArr.shift();
+        let curVal = valArr.shift();
+        curVal += curNode.val;
+        // 为叶子结点，且和等于目标数，返回true
+        if (curNode.left === null && curNode.right === null && curVal === targetSum) {
+            return true;
+        }
+        // 左节点，将当前的数值也对应记录下来
+        if (curNode.left) {
+            nodeArr.push(curNode.left);
+            valArr.push(curVal);
+        }
+        // 右节点，将当前的数值也对应记录下来
+        if (curNode.right) {
+            nodeArr.push(curNode.right);
+            valArr.push(curVal);
+        }
+    }
+    return false;
+};
+```
 
 0113.路径总和-ii 
 
+**递归**
 ```javascript
 let pathsum = function (root, targetsum) {
   // 递归法
@@ -677,7 +707,7 @@ let pathsum = function (root, targetsum) {
   return res;
 };
 ```
-113 路径总和 精简版
+**递归 精简版**
 ```javascript
 var pathsum = function(root, targetsum) {
     //递归方法
@@ -701,6 +731,41 @@ var pathsum = function(root, targetsum) {
     return resPath;
 };
 ```
+**迭代**
+```javascript
+let pathSum = function(root, targetSum) {
+    if(root === null) return [];
+    let nodeArr = [root];
+    let resArr = []; // 记录符合目标和的返回路径
+    let tempArr = [[]]; // 对应路径
+    let countArr = [0]; //对应和
+    while(nodeArr.length) {
+        let curNode = nodeArr.shift();
+        let curVal = countArr.shift();
+        let curNodeArr = tempArr.shift();
+        curVal += curNode.val;
+        curNodeArr.push(curNode.val);
+        // 为叶子结点，且和等于目标数，将此次结果数组push进返回数组中
+        if (curNode.left === null && curNode.right === null && curVal === targetSum) {
+            resArr.push(curNodeArr);
+        }
+        // 左节点，将当前的和及对应路径也对应记录下来
+        if (curNode.left) {
+            nodeArr.push(curNode.left);
+            countArr.push(curVal);
+            tempArr.push([...curNodeArr]);
+        }
+         // 右节点，将当前的和及对应路径也对应记录下来
+        if (curNode.right) {
+            nodeArr.push(curNode.right);
+            countArr.push(curVal);
+            tempArr.push([...curNodeArr]);
+        }
+    }
+    return resArr;
+};
+```
+