update: 110

Author: hijiangtao

README.md

@@ -65,6 +65,7 @@ This is the solutions collection of my LeetCode submissions, most of them are pr
 | 104 | [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/)                                                     | [JavaScript](./src/maximum-depth-of-binary-tree/res.js)                           | Easy       |
 | 107 | [Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/)                                     | [JavaScript](./src/binary-tree-level-order-traversal-ii/res.js)                   | Easy       |
 | 108 | [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/)                         | [JavaScript](./src/convert-sorted-array-to-binary-search-tree/res.js)             | Easy       |
+| 110 | [balanced-binary-tree](https://leetcode.com/problems/balanced-binary-tree/)                                                                     | [TypeScript](./src/balanced-binary-tree/res.ts)                                   | Easy       |
 | 111 | [Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/)                                                     | [JavaScript](./src/minimum-depth-of-binary-tree/res.js)                           | Easy       |
 | 120 | [Triangle](https://leetcode.com/problems/triangle/)                                                                                             | [JavaScript](./src/triangle/res.js)                                               | Medium     |
 | 121 | [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)                                               | [JavaScript](./src/best-time-to-buy-and-sell-stock/res.js)                        | Easy       |

src/balanced-binary-tree/res.ts

@@ -0,0 +1,68 @@
+/**
+ * Definition for a binary tree node.
+ */
+class TreeNode {
+    val: number
+    left: TreeNode | null
+    right: TreeNode | null
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = (val===undefined ? 0 : val)
+        this.left = (left===undefined ? null : left)
+        this.right = (right===undefined ? null : right)
+    }
+}
+
+function getTreeLength(root: TreeNode | null): number {
+    if (!root) {
+        return 0;
+    } else {
+        return 1 + Math.max(getTreeLength(root.left), getTreeLength(root.right));
+    }
+}
+
+/**
+ * 自上而下递归
+ *
+ * 时间复杂度：O(n^2)，其中 n 是二叉树中的节点个数。
+ * 最坏情况下，二叉树是满二叉树，需要遍历二叉树中的所有节点，时间复杂度是 O(n)。
+ * 对于节点 p，如果它的高度是 d，则 height(p) 最多会被调用 d 次（即遍历到它的每一个祖先节点时）。对于平均的情况，一棵树的高度 h 满足 O(h)=O(logn)，因为 d≤h，所以总时间复杂度为 O(nlogn)。对于最坏的情况，二叉树形成链式结构，高度为 O(n)，此时总时间复杂度为 O(n^2)。
+ *
+ * 空间复杂度：O(n)，其中 n 是二叉树中的节点个数。空间复杂度主要取决于递归调用的层数，递归调用的层数不会超过 n。
+ * @param root
+ */
+function isBalanced(root: TreeNode | null): boolean {
+    if (!root || !root.left && !root.right) {
+        return true;
+    } else {
+        return isBalanced(root.left) && isBalanced(root.right) && Math.abs(getTreeLength(root.left) - getTreeLength(root.right)) <= 1;
+    }
+};
+
+function getBalancedLength(root: TreeNode | null): number {
+    if (!root) {
+        return 0;
+    } else {
+        const leftLength = getBalancedLength(root.left);
+        const rightLength = getBalancedLength(root.right);
+
+        if (leftLength < 0 || rightLength < 0 || Math.abs(leftLength - rightLength) > 1) {
+            return -1;
+        } else {
+            return Math.max(leftLength, rightLength) + 1;
+        }
+    }
+}
+
+/**
+ * 自底向上的递归
+ *
+ * 复杂度均为 O(n)
+ * @param root
+ */
+function isBalanced2(root: TreeNode | null): boolean {
+    if (!root || !root.left && !root.right) {
+        return true;
+    } else {
+        return getBalancedLength(root) >= 0;
+    }
+};