题110，124

Author: ligecarryme

入门/力扣经典算法.md 入门（Java）/力扣经典算法.md入门/力扣经典算法.md renamed to 入门（Java）/力扣经典算法.md

@@ -136,7 +136,7 @@ public void traversePostOrderWithoutRecursion() {	//后序的递归后续理解
 
     while (!stack.isEmpty()) {
         current = stack.peek();
-        boolean hasChild = (current.left != null || current.right != null);//!!!
+        boolean hasChild = (current.left != null || current.right != null);
         boolean isPrevLastChild = (prev == current.right || 
           (prev == current.left && current.right == null));
 

数据结构篇/二叉树.md

@@ -14,7 +14,8 @@
 ```js
 function TreeNode(val){
     this.val = val;
-    this.left = this.right = null;
+    this.left = null;
+    this.right = null;
 }
 ```
 
@@ -39,7 +40,7 @@ const binaryTree = function (array) {
     return buildTreeByArray(array, 0);
 }
 
-let arr = [1,2,3,null,4,5,null,null,null,6,7];
+const arr = [1,2,3,null,4,5,null,null,null,6,7];
 let root = binaryTree(arr);
 ```
 
@@ -59,15 +60,15 @@ function preOrder(root) {
 ##### 前序非递归
 
 ```js
-var preOrderTraversal = function (root) {
+const preOrderTraversal = function (root) {
     if(root === null){
         return [];
     }
-    let res = [];
-    let stack = [];
+    const res = [];
+    const stack = [];
     stack.push(root);
     while(stack.length !== 0){
-        let node = stack.pop();
+        const node = stack.pop();
         res.push(node.val);
         if (node.right !== null) {
             stack.push(node.right);
@@ -96,12 +97,12 @@ function inOrder(root){
 ##### 中序非递归
 
 ```js
-var inOrderTraversal = function(root){
+const inOrderTraversal = function(root){
     if (root === null) {
         return [];
     }
-    let res = [];
-    let stack = [];
+    const res = [];
+    const stack = [];
     let node = root;
     while(stack.length!==0 || node!==null){
         while(node !== null){
@@ -132,12 +133,12 @@ function postOrder(root){
 ##### 后序非递归
 
 ```js
-var postOrderTraversal = function(root){  //翻转非递归 后序遍历
+const postOrderTraversal = function(root){  //翻转非递归 后序遍历
     if (root === null) {
         return [];
     }
-    let res = [];
-    let stack = [];
+    const res = [];
+    const stack = [];
     stack.push(root);
     while(stack.length !== 0){
         let node = stack.pop();
@@ -153,16 +154,16 @@ var postOrderTraversal = function(root){  //翻转非递归 后序遍历
 }
 ```
 
-##### 深度遍历
+##### 深度搜索
 
 ```js
-var dfsUpToDown = function(root){  //递归，从上到下
-    let res = [];
+const dfsUpToDown = function(root){  //递归，从上到下
+    const res = [];
     dfs(root, res);
     return res;
 }
 
-var dfs = function(node, res){
+const dfs = function(node, res){
     if (node === null) {
         return null;
     }
@@ -171,12 +172,12 @@ var dfs = function(node, res){
     dfs(node.right, res);
 }
 
-var dfsDownToUp = function(root){ //从下到上
+const dfsDownToUp = function(root){  //从下到上
     return divideAndConquer(root);
 }
 
-var divideAndConquer = function(node){ // 分治法
-    let res = [];
+const divideAndConquer = function(node){  //分治法
+    const res = [];
     if (node === null) {
         return null;
     }
@@ -193,12 +194,12 @@ var divideAndConquer = function(node){ // 分治法
 }
 ```
 
-##### 广度遍历
+##### 广度搜索
 
 ```js
-var bfs = function(root){
+const bfs = function(root){
     let res = [];
-    let queue = [];
+    const queue = [];
     queue.push(root);
     while(queue.length !== 0){
         let node = queue.shift();
@@ -214,7 +215,7 @@ var bfs = function(root){
 }
 ```
 
-##### 104.二叉树的最大深度[二叉树的最大深度](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
+##### 104.[二叉树的最大深度](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
 
 给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。**说明:** 叶子节点是指没有子节点的节点。
 
@@ -229,11 +230,68 @@ var bfs = function(root){
 > 返回它的最大深度 3 。
 
 ```js
-var maxDepth = function(root) {   //递归
+const maxDepth = function(root) {   //递归
     if(root === null){
         return 0;
     }
-    return Math.max(maxDepth(root.left), 								maxDepth(root.right))+1;
+    return Math.max(maxDepth(root.left), maxDepth(root.right))+1;
+};
+```
+
+110.[平衡二叉树](https://leetcode-cn.com/problems/balanced-binary-tree/)
+
+给定一个二叉树，判断它是否是高度平衡的二叉树。
+
+```js
+const isBalanced = function(root) {
+    if(maxDepth(root) === -1) {
+        return false
+    }
+    return true
+};
+
+const maxDepth = function(root) {
+    if(root === null) {
+        return 0
+    }
+    const left = maxDepth(root.left)
+    const right = maxDepth(root.right)
+    if(left === -1 || right === -1 || Math.abs(right - left) > 1) { //判断左右子树的高度
+        return -1
+    }
+    if(left > right) {
+        return left + 1
+    }else{
+        return right + 1
+    }
+
+}
+```
+
+124.[二叉树中的最大路径和](https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/)
+
+**路径** 被定义为一条从树中任意节点出发，沿父节点—子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 **至多出现一次** 。该路径 **至少包含一个** 节点，且不一定经过根节点。
+
+**路径和** 是路径中各节点值的总和。
+
+给你一个二叉树的根节点 `root` ，返回其 **最大路径和** 。
+
+> 思路：分治法，分为三种情况：左子树最大路径和最大，右子树最大路径和最大，左右子树最大加根节点最大，需要保存两个变量：一个保存子树最大路径和，一个保存左右加根节点和，然后比较这个两个变量选择最大值即可
+
+```js
+var maxPathSum = function (root) {
+    let maxSum = Number.MIN_SAFE_INTEGER
+    function maxGain(node) {
+        if (!node) {
+            return 0
+        }
+        const left = maxGain(node.left)
+        const right = maxGain(node.right)
+        maxSum = Math.max(maxSum, node.val, node.val + left + right, node.val + left, node.val + right)
+        return Math.max(node.val, node.val + left, node.val + right)
+    }
+    maxGain(root)
+    return maxSum
 };
 ```