diff --git "a/Tree/\345\256\266/.keep" "b/Tree/\345\256\266/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/Tree/\345\256\266/\345\256\266_124.md" "b/Tree/\345\256\266/\345\256\266_124.md"
new file mode 100644
index 0000000000000000000000000000000000000000..103eb0c188e8666ac995852129d7c6d799abb6dc
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_124.md"
@@ -0,0 +1,32 @@
+```
+/**
+ * 作者：家
+ * 思路：深度优先就好。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+func maxPathSum(root *TreeNode) int {
+    re := -2 << 31
+    dfs := func(*TreeNode) int {
+        return 0
+    }
+    dfs = func(root *TreeNode) int {
+        if root == nil {
+            return 0
+        }
+        left := max(0,dfs(root.Left))
+        right := max(0,dfs(root.Right))
+        re = max(re, left+right+root.Val)
+        return max(left,right)+root.Val
+    }
+    dfs(root)
+    return re
+}
+
+func max(a,b int)int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
\ No newline at end of file
diff --git "a/Tree/\345\256\266/\345\256\266_144.md" "b/Tree/\345\256\266/\345\256\266_144.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d5ebecda3cf21e7fdd05f5c4ddd059195b8fbb5b
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_144.md"
@@ -0,0 +1,26 @@
+```
+/**
+ * 作者：家
+ * 思路：用一个队列玩就行。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+func preorderTraversal(root *TreeNode) []int {
+    s := []*TreeNode{}
+    re := []int{}
+    for {
+        for root != nil {
+            re = append(re,root.Val)
+            s = append(s,root)
+            root = root.Left
+        }
+        l := len(s)
+        if l == 0 {
+            return re
+        }
+        root = s[l-1].Right
+        s = s[:l-1]
+    }
+    return re
+}
+```
\ No newline at end of file
diff --git "a/Tree/\345\256\266/\345\256\266_145.md" "b/Tree/\345\256\266/\345\256\266_145.md"
new file mode 100644
index 0000000000000000000000000000000000000000..24f77a7a7105fdc7d71a277c633f28c6ee8535ed
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_145.md"
@@ -0,0 +1,31 @@
+```
+/**
+ * 作者：家
+ * 思路：三个里最难的一个，有个技巧，因为后序就是【左右根】，那么我们可以先序的【根右左】遍历，然后反转结果就好。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+func postorderTraversal(root *TreeNode) []int {
+    s := []*TreeNode{}
+    re := []int{}
+    for {
+        for root != nil {
+            re = append(re,root.Val)
+            s = append(s,root)
+            root = root.Right
+        }
+        l := len(s)
+        if l == 0 {
+            res := make([]int,len(re))
+            for i:=0; i<len(res); i++ {
+                res[i] = re[len(res)-1-i]
+            }
+            return res
+        }
+        root = s[l-1].Left
+        s = s[:l-1]
+    }
+    
+    return re
+}
+```
\ No newline at end of file
diff --git "a/Tree/\345\256\266/\345\256\266_226.md" "b/Tree/\345\256\266/\345\256\266_226.md"
new file mode 100644
index 0000000000000000000000000000000000000000..187bee9e8dc05b931a35d6175d260f5c630ed7c5
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_226.md"
@@ -0,0 +1,17 @@
+```
+/**
+ * 作者：家
+ * 思路：前序后序遍历都行，遍历的同时把当前节点的左右孩子换一下就行。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+func invertTree(root *TreeNode) *TreeNode {
+    if root == nil {
+        return root
+    }
+    root.Left,root.Right = root.Right,root.Left
+    invertTree(root.Left)
+    invertTree(root.Right)
+    return root
+}
+```
\ No newline at end of file
diff --git "a/Tree/\345\256\266/\345\256\266_235.md" "b/Tree/\345\256\266/\345\256\266_235.md"
new file mode 100644
index 0000000000000000000000000000000000000000..054b61d750044ecc4d1d05acff5615cf4af60e3c
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_235.md"
@@ -0,0 +1,15 @@
+```
+/**
+ * 作者：家
+ * 思路：毕竟是二叉搜索树，按照当前节点跟左右孩子的大小关系就可以找到公共祖先
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if p.val > root.val < q.val:
+            return self.lowestCommonAncestor(root.right, p, q)
+        elif p.val < root.val > q.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        else: return root
+```
\ No newline at end of file
diff --git "a/Tree/\345\256\266/\345\256\266_236.md" "b/Tree/\345\256\266/\345\256\266_236.md"
new file mode 100644
index 0000000000000000000000000000000000000000..573cff265affbdc14c66b9b501361675008f2aae
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_236.md"
@@ -0,0 +1,14 @@
+```
+/**
+ * 作者：家
+ * 思路：二叉树，递归结构是如果当前节点的左右各有p、q其中一个，那么当前就是公共祖先，如果其中一边有两个，那么直接去那一边找。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if root in [None,p,q] : return root
+        left = self.lowestCommonAncestor(root.left, p, q)
+        right = self.lowestCommonAncestor(root.right, p, q)
+        return right if left == None else left if right == None else root
+```
\ No newline at end of file
diff --git "a/Tree/\345\256\266/\345\256\266_94.md" "b/Tree/\345\256\266/\345\256\266_94.md"
new file mode 100644
index 0000000000000000000000000000000000000000..099f21efec5344974fce1b0971c6d0acfbb08047
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_94.md"
@@ -0,0 +1,26 @@
+```
+/**
+ * 作者：家
+ * 思路：用一个队列玩就行。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+func inorderTraversal(root *TreeNode) []int {
+    s := []*TreeNode{}
+    re := []int{}
+    for {
+        for root != nil {
+            s = append(s,root)
+            root = root.Left
+        }
+        if len(s) == 0 {
+            return re
+        }
+        l := len(s)-1
+        re = append(re,s[l].Val)
+        root = s[l].Right
+        s = s[:l]
+    }
+    return re
+}
+```
\ No newline at end of file
diff --git "a/Tree/\345\256\266/\345\256\266_98.md" "b/Tree/\345\256\266/\345\256\266_98.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6d7065233be0f0f8f4626f5997c2807755ce7a18
--- /dev/null
+++ "b/Tree/\345\256\266/\345\256\266_98.md"
@@ -0,0 +1,15 @@
+```
+/**
+ * 作者：家
+ * 思路：深度优先把节点都判断一下就好
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+class Solution:
+    def isValidBST(self, root: TreeNode) -> bool:
+        def valid(root: TreeNode, m:int ,l: int) -> bool:
+            if root == None : return True
+            if root.val >= m or root.val <= l : return False
+            return valid(root.left, root.val,l) and valid(root.right, m,root.val)
+        return valid(root,2 << 31, -2 << 31)
+```
\ No newline at end of file