diff --git a/ArrayAndLink/Daryl_206.png b/ArrayAndLink/Daryl_206.png
new file mode 100644
index 0000000000000000000000000000000000000000..e5664f8a6a6366bae782b4df966f6e8b41187a46
Binary files /dev/null and b/ArrayAndLink/Daryl_206.png differ
diff --git "a/StackAndQueue/\345\256\266/.keep" "b/StackAndQueue/\345\256\266/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/StackAndQueue/\345\256\266/\345\256\266_20.md" "b/StackAndQueue/\345\256\266/\345\256\266_20.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ee942cb9f8f0e6a5e57e0a0d8cf3588494d3ef1c
--- /dev/null
+++ "b/StackAndQueue/\345\256\266/\345\256\266_20.md"
@@ -0,0 +1,20 @@
+```go
+/**
+ * 作者：家
+ * 思路：用字典储存对应的括号，遍历字符串，遇到左括号压栈，遇到右括号检查栈顶是否对应，对应即可弹出，最后判断栈是否为空。
+ *      当然如果开心的话，可以先判断字符串长度，为奇数直接return False
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = []
+        dicts = {')': '(', ']': '[', '}': '{'}
+        for x in s :
+            if x in ["(","[","{"] :
+                stack.append(x)
+            else :
+                if len(stack) == 0 or stack.pop() != dicts[x] :
+                    return False             
+        return len(stack) == 0
+```        
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266/\345\256\266_225.md" "b/StackAndQueue/\345\256\266/\345\256\266_225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f171e138713e141b6727ecf582ec6209dcac0791
--- /dev/null
+++ "b/StackAndQueue/\345\256\266/\345\256\266_225.md"
@@ -0,0 +1,28 @@
+```go
+/**
+ * 作者：家
+ * 思路：正统的思路肯定是两个队列模拟栈，如果只是刷题的话用python列表的特性即可实现。
+ * 时间复杂度：
+ * push:O(1)
+ * pop:O(1)
+ * top:O(1)
+ * empty:O(1)
+ * 空间复杂度：O(n)
+ */
+class MyStack:
+
+    def __init__(self):
+        self.stack = []
+        
+    def push(self, x: int) -> None:
+        self.stack.append(x)
+        
+    def pop(self) -> int:
+        return self.stack.pop()
+        
+    def top(self) -> int:
+        return self.stack[-1]
+        
+    def empty(self) -> bool:
+        return not self.stack
+```        
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266/\345\256\266_232.md" "b/StackAndQueue/\345\256\266/\345\256\266_232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6ad0e5573123af2cb54542907b3e80a127014220
--- /dev/null
+++ "b/StackAndQueue/\345\256\266/\345\256\266_232.md"
@@ -0,0 +1,28 @@
+/**
+ * 作者：家
+ * 思路：正统的思路肯定是两个栈模拟队列，如果只是刷题的话用python列表的特性即可实现。
+ * 时间复杂度：
+ * push:O(1)
+ * pop:O(1)
+ * peek:O(1)
+ * empty:O(1)
+ * 空间复杂度：O(n)
+ */
+class MyQueue:
+
+    def __init__(self):
+        self.queue = []
+
+    def push(self, x: int) -> None:
+        self.queue.append(x)   
+
+    def pop(self) -> int:
+        tmp = self.queue[0]
+        self.queue = self.queue[1:]
+        return tmp
+
+    def peek(self) -> int:
+        return self.queue[0]
+        
+    def empty(self) -> bool:
+        return not self.queue
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266/\345\256\266_239.md" "b/StackAndQueue/\345\256\266/\345\256\266_239.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cbaacaa513307af0b20185b13ad2387edc46ea5c
--- /dev/null
+++ "b/StackAndQueue/\345\256\266/\345\256\266_239.md"
@@ -0,0 +1,28 @@
+```go
+/**
+ * 作者：家
+ * 思路：用队列来实现就可以了，这个队列长度为k，保证队首元素为队列中的最大元素即可。详情在代码，更详情在博客，博客链接后续补上。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(k)
+ */
+class Solution:
+    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
+        l = len(nums)
+        if l == 0 or k == 0 :
+            return []
+        queue,re = [],[]
+        for i in range(len(nums)) :
+            //如果队列中元素大于k就pop
+            if i >= k and i-queue[0] >= k :
+                queue = queue[1:]
+            //循环，把队列中小于新元素的元素pop掉
+            while len(queue) > 0 and nums[i] >= nums[queue[len(queue)-1]] :
+                queue = queue[:len(queue)-1]
+            //队列中存的是索引
+            queue.append(i)
+            if i >= k-1 :
+                re.append(nums[queue[0]])
+                
+        return re
+
+```
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266/\345\256\266_703.md" "b/StackAndQueue/\345\256\266/\345\256\266_703.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6f73df0b40e6d104cc95ffe90cc16cfcc3062665
--- /dev/null
+++ "b/StackAndQueue/\345\256\266/\345\256\266_703.md"
@@ -0,0 +1,25 @@
+```go
+/**
+ * 作者：家
+ * 思路：用一个小顶堆来实现，并且保证长度为k即可。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+from heapq import heappush, heapify, heappop, heappushpop
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.k = k
+        self.heap = nums
+        heapify(self.heap)
+        while len(self.heap) > k:
+            heappop(self.heap)
+
+    def add(self, val: int) -> int:
+        if len(self.heap) < self.k:
+            heappush(self.heap, val)
+        else:
+            heappushpop(self.heap, val)
+        return self.heap[0]
+
+```
\ No newline at end of file
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