BeckShe
diff --git a/‎README.md‎
Lines changed: 1 addition & 0 deletions b/‎README.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎leetcode_others/main.md‎ b/‎leetcode_others/main.md‎
diff --git a/‎leetcode_tree/main.md‎
Lines changed: 9 additions & 6 deletions b/‎leetcode_tree/main.md‎
Lines changed: 9 additions & 6 deletions
diff --git a/‎leetcode_tree/二叉树的所有路径.md‎
Lines changed: 70 additions & 0 deletions b/‎leetcode_tree/二叉树的所有路径.md‎
Lines changed: 70 additions & 0 deletions
diff --git a/‎leetcode_tree/另一个树的子树.md‎
Lines changed: 51 additions & 0 deletions b/‎leetcode_tree/另一个树的子树.md‎
Lines changed: 51 additions & 0 deletions
diff --git a/‎leetcode_tree/左叶子之和.md‎
Lines changed: 70 additions & 0 deletions b/‎leetcode_tree/左叶子之和.md‎
Lines changed: 70 additions & 0 deletions
diff --git a/‎leetcode_tree/平衡二叉树.md‎
Lines changed: 13 additions & 29 deletions b/‎leetcode_tree/平衡二叉树.md‎
Lines changed: 13 additions & 29 deletions
diff --git a/‎leetcode_tree/找树左下角的值.md‎
Lines changed: 41 additions & 0 deletions b/‎leetcode_tree/找树左下角的值.md‎
Lines changed: 41 additions & 0 deletions
@@ -11,5 +11,6 @@
 |[LeetCode-哈希表](./leetcode_hash/main.md)|leetcode哈希表类算法练习|
 |[LeetCode-栈+队列](./leetcode_stack/main.md)|leetcode栈+队列类算法练习|
 |[LeetCode-二叉树](./leetcode_tree/main.md)|leetcode二叉树类算法练习|
+|[LeetCode-其他](../leetcode_others/main.md)|leetcode其他分类算法练习|
 |[Django学习](./django_note/main.md)|Django学习笔记。|
 |[其他](./others/main.md)|redis，kafka，ZeroMQ等|
@@ -44,15 +44,18 @@
 * [二叉树的层序遍历](二叉树的层序遍历.md)
 * [反转二叉树](反转二叉树.md)
 * [对称二叉树](对称二叉树.md)
+* [相同的树](相同的树.md)
+* [另一个树的子树](另一个树的子树.md)
 * [二叉树的最大深度](二叉树的最大深度.md)
 * [二叉树的最小深度](二叉树的最小深度.md)
 * [完全二叉树的节点个数](完全二叉树的节点个数.md)
+* [平衡二叉树](平衡二叉树.md)
+* [二叉树的所有路径](二叉树的所有路径.md)
+* [左叶子之和](左叶子之和.md)
+* [找树左下角的值](找树左下角的值.md)
+* [路径总和](路径总和.md)
 
-1. [相同的树](相同的树.md)
-
-2. [对称二叉树](对称二叉树.md)
-3.
+<!--
 4. [二叉树的层次遍历 II](二叉树的层次遍历II.md)
 5. [将有序数组转换为二叉搜索树](将有序数组转换为二叉搜索树.md)
-6. [平衡二叉树](平衡二叉树.md)
-7. [二叉树的最小深度](二叉树的最小深度.md)
+-->
@@ -0,0 +1,70 @@
+# 257.二叉树的所有路径
+## 题目  
+给定一个二叉树，返回所有从根节点到叶子节点的路径。
+
+说明: 叶子节点是指没有子节点的节点。
+
+```python
+输入:
+
+   1
+ /   \
+2     3
+ \
+  5
+
+输出: ["1->2->5", "1->3"]
+
+解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
+```
+
+## 分析
+#### 迭代
+
+* 定义两个队列，一个队列存储节点，一个队列存储根到该节点的路径
+* 遍历每一个节点的同时，也在记录路径，直到叶子节点，将路径添加到返回列表中
+
+![](../pic/leetcode_tree/257_1.gif)
+
+```python
+from queue import Queue
+def binaryTreePaths(root):
+    if not root:
+        return []
+    node_queue = Queue()
+    path_queue = Queue()
+    node_queue.put(root)
+    path_queue.put(str(root.val))
+
+    ans = []
+    while node_queue.qsize():
+        node = node_queue.get()
+        path = path_queue.get()
+        if node.left:
+            node_queue.put(node.left)
+            path_queue.put(path + '->' + str(node.left.val))
+        if node.right:
+            node_queue.put(node.right)
+            path_queue.put(path + '->' + str(node.right.val))
+        if node.left is None and node.right is None:
+           ans.append(path)
+    return ans
+```
+
+#### 递归
+```python
+def binaryTreePaths(root):
+    def construct_paths(root, path):
+        if root:
+            path += str(root.val)
+            if root.left is None and root.right is None:
+                ans.append(path)
+            else:
+                path += '->'
+                construct_paths(root.left, path)
+                construct_paths(root.right, path)
+
+    ans = []
+    construct_paths(root, '')
+    return ans
+```
@@ -0,0 +1,51 @@
+# 572.另一个树的子树
+## 题目
+给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。
+```python
+给定的树 s:
+      3
+     / \
+    4   5
+   / \
+  1   2
+给定的树 t：
+  4
+ / \
+1   2
+返回 true，因为 t 与 s 的一个子树拥有相同的结构和节点值。
+```
+
+## 分析
+迭代，遍历s树，如果子树的根节点与t树的根节点相等，再去判断两个数是否相等，[相同的树](相同的树.md)
+```python
+from queue import Queue
+def isSubtree(s, t):
+    def isSame(p, q):
+        if p is None and q is None:
+            return True
+        if not p or not q:
+            return False
+        if p.val != q.val:
+            return False
+        else:
+            return isSame(p.left, q.left) and isSame(p.right, q.right)
+
+    Q = Queue()
+    Q.put(s)
+    while Q.qsize():
+        node = Q.get()
+        if node.val == t.val:
+            if isSame(node, t):
+                return True
+            else:
+                if node.left:
+                    Q.put(node.left)
+                if node.right:
+                    Q.put(node.right)
+        else:
+            if node.left:
+                Q.put(node.left)
+            if node.right:
+                Q.put(node.right)
+    return False
+```
@@ -0,0 +1,70 @@
+# 404.左叶子之和
+## 题目
+计算给定二叉树的所有左叶子之和。
+```python
+     3
+    / \
+    9  20
+      /  \
+     15   7
+
+在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24
+```
+
+## 分析
+#### 迭代
+遍历树，如果一个节点的左节点是叶子节点，就累加
+
+```python
+from queue import Queue
+def sumOfLeftLeaves(root):
+    def isLeavesNode(node):
+        # 判断一个节点是不是叶子节点
+        if node.left is None and node.right is None:
+            return True
+        return False
+
+    if not root:
+        return 0
+    ans = 0
+    q = Queue()
+    q.put(root)
+    while q.qsize():
+        node = q.get()
+        if node.left:
+            if isLeavesNode(node.left):
+                ans += node.left.val
+            else:
+                q.put(node.left)
+
+        if node.right:
+            if not isLeavesNode(node.right):
+                q.put(node.right)
+    return ans
+```
+
+#### 深度优先搜索
+```python
+def sumOfLeftLeaves(root):
+    def isLeavesNode(node):
+        # 判断一个节点是不是叶子节点
+        if node.left is None and node.right is None:
+            return True
+        return False
+
+    def dfs(root):
+        ans = 0
+        if root.left:
+            if isLeavesNode(root.left):
+                ans += root.left.val
+            else:
+                ans += dfs(root.left)
+        if root.right:
+            if not isLeavesNode(root.right):
+                ans += dfs(root.right)
+        return ans
+
+    if not root:
+        return 0
+    return dfs(root)
+```
@@ -1,4 +1,5 @@
-## 平衡二叉树
+# 110.平衡二叉树
+## 题目
 给定一个二叉树，判断它是否是高度平衡的二叉树。一棵高度平衡二叉树定义为：
 
 **一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。**
@@ -9,39 +10,22 @@
 输出：true
 ```
 
-#### 代码
-自顶向下递归
+## 分析
 * 左右两个子树的高度差小于等于1
 * 平衡二叉树的两个子树也是平衡二叉树
 
-```python
-class Solution:
-    def isBalanced(self, root: TreeNode) -> bool:
-        def maxHeight(node):
-            if not node:
-                return 0
-            return max(maxHeight(node.left), maxHeight(node.right)) + 1
-        if not root:
-            return True
-        left = root.left  # 左子树
-        right = root.right  # 右子树
-        if self.isBalanced(left) and self.isBalanced(right) and abs(maxHeight(left) - maxHeight(right)) <= 1:
-            return True
-        return False
-```
-
-自底向上（没懂）
-
 ```python
 def isBalanced(root):
-    def heigh(root):
+    def depth(root):
+        # 计算树的深度
         if not root:
             return 0
-        left_height = heigh(root.left)
-        right_height = heigh(root.right)
-        if left_height == -1 or right_height == -1 or abs(left_height-right_height) > 1:
-            return -1
-        else:
-            return max(left_height, right_height) + 1
-    return heigh(root) >= 0
+        return 1 + max(depth(root.left), depth(root.right))
+
+    if not root:
+        return True
+    left = root.left
+    right = root.right
+    return isBalanced(left) and isBalanced(right) and abs(depth(left) - depth(right)) <= 1
+
 ```
@@ -0,0 +1,41 @@
+# 513.找树左下角的值
+## 题目
+给定一个二叉树，在树的最后一行找到最左边的值。
+```python
+输入:
+
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+       /
+      7
+
+输出:
+7
+```
+
+## 分析
+#### 迭代
+层序遍历，队列中存放的都是同一层的节点，每一层第一个节点就是最左边的节点
+
+```python
+from queue import Queue
+def findBottomLeftValue(root):
+    q = Queue()
+    q.put(root)
+    while q.qsize():
+        ans = None
+        size = q.qsize()
+        for _ in range(size):
+            node = q.get()
+            if not ans:
+                # 记录每一层最左边的节点
+                ans = node
+            if node.left:
+                q.put(node.left)
+            if node.right:
+                q.put(node.right)
+    return ans.val
+```