diff --git a/ArrayAndLink/LinkedList/Kilien/LeetCode 148.Sort List.jpg b/ArrayAndLink/Kilien/LeetCode 148.Sort List.jpg
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/LeetCode 148.Sort List.jpg
rename to ArrayAndLink/Kilien/LeetCode 148.Sort List.jpg
diff --git a/ArrayAndLink/LinkedList/Kilien/Leetcode 141.Linked List Cycle.jpg b/ArrayAndLink/Kilien/Leetcode 141.Linked List Cycle.jpg
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/Leetcode 141.Linked List Cycle.jpg
rename to ArrayAndLink/Kilien/Leetcode 141.Linked List Cycle.jpg
diff --git a/ArrayAndLink/LinkedList/Kilien/Leetcode 206.Reverse Linked List.jpg b/ArrayAndLink/Kilien/Leetcode 206.Reverse Linked List.jpg
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/Leetcode 206.Reverse Linked List.jpg
rename to ArrayAndLink/Kilien/Leetcode 206.Reverse Linked List.jpg
diff --git a/ArrayAndLink/LinkedList/Kilien/Leetcode 24.Swap Nodes in Pairs.jpg b/ArrayAndLink/Kilien/Leetcode 24.Swap Nodes in Pairs.jpg
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/Leetcode 24.Swap Nodes in Pairs.jpg
rename to ArrayAndLink/Kilien/Leetcode 24.Swap Nodes in Pairs.jpg
diff --git a/ArrayAndLink/LinkedList/Kilien/LinkedListCycle.py b/ArrayAndLink/Kilien/LinkedListCycle.py
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/LinkedListCycle.py
rename to ArrayAndLink/Kilien/LinkedListCycle.py
diff --git a/ArrayAndLink/LinkedList/Kilien/SortList.py b/ArrayAndLink/Kilien/SortList.py
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/SortList.py
rename to ArrayAndLink/Kilien/SortList.py
diff --git a/ArrayAndLink/LinkedList/Kilien/SwapNodesinPairs.py b/ArrayAndLink/Kilien/SwapNodesinPairs.py
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/SwapNodesinPairs.py
rename to ArrayAndLink/Kilien/SwapNodesinPairs.py
diff --git a/ArrayAndLink/LinkedList/Kilien/reverse-linked-list.py b/ArrayAndLink/Kilien/reverse-linked-list.py
similarity index 100%
rename from ArrayAndLink/LinkedList/Kilien/reverse-linked-list.py
rename to ArrayAndLink/Kilien/reverse-linked-list.py
diff --git a/StackAndQueue/Kilien/20.valid-parentheses.py b/StackAndQueue/Kilien/20.valid-parentheses.py
new file mode 100644
index 0000000000000000000000000000000000000000..66d52fd57b3ea4f328994cd2f548682f7b47368d
--- /dev/null
+++ b/StackAndQueue/Kilien/20.valid-parentheses.py
@@ -0,0 +1,19 @@
+# @Author：Kilien
+# @lc app=leetcode id=20 lang=python3
+#
+# [20] Valid Parentheses
+# 思路：使用hashtable标记括号，拆分字符串
+# 若字符串不在hashtable中模拟入栈
+# 若栈不为空，出栈匹配括号则消除，不匹配则报错
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = []
+        par_map = {')':'(',']':'[','}':'{'}
+
+        for c in s:
+            if c not in par_map:
+                stack.append(c)
+            elif not stack or par_map[c] != stack.pop():
+                return False
+        return not stack 
+
diff --git a/StackAndQueue/Kilien/225.implement-stack-using-queues.py b/StackAndQueue/Kilien/225.implement-stack-using-queues.py
new file mode 100644
index 0000000000000000000000000000000000000000..c928b915ff3044ebe650e8c1459581d38e2faba9
--- /dev/null
+++ b/StackAndQueue/Kilien/225.implement-stack-using-queues.py
@@ -0,0 +1,50 @@
+# @Author：Kilien
+# @lc app=leetcode id=225 lang=python3
+# [225] Implement Stack using Queues
+# time：O（1） space：O（n）
+# 思路：双端队列，左进右出模拟栈
+
+class MyStack:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.stack = collections.deque([])
+        
+
+    def push(self, x: int) -> None:
+        """
+        Push element x onto stack.
+        """
+        self.stack.append(x)
+
+
+    def pop(self) -> int:
+        """
+        Removes the element on top of the stack and returns that element.
+        """
+        for i in range(len(self.stack) - 1):
+            self.stack.append(self.stack.popleft())
+        return self.stack.popleft()        
+
+    def top(self) -> int:
+        """
+        Get the top element.
+        """
+        return self.stack[-1]
+
+    def empty(self) -> bool:
+        """
+        Returns whether the stack is empty.
+        """
+        return len(self.stack) == 0
+
+
+# Your MyStack object will be instantiated and called as such:
+# obj = MyStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.empty()
+
diff --git a/StackAndQueue/Kilien/232.implement-queue-using-stacks.py b/StackAndQueue/Kilien/232.implement-queue-using-stacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..744a1be40bc0108f40730cf1ab3a23853c53edf0
--- /dev/null
+++ b/StackAndQueue/Kilien/232.implement-queue-using-stacks.py
@@ -0,0 +1,55 @@
+# @Author：Kilien
+# @lc app=leetcode id=232 lang=python3
+# [232] Implement Queue using Stacks
+# time:O(1) space:O(n)
+#思路：两个数组，模拟入栈出栈，实现队列
+class MyQueue:
+
+    def __init__(self):
+        """
+        initialize your data structure here.
+        """
+        self.inStack, self.outStack = [], []
+
+    def push(self, x):
+        """
+        :type x: int
+        :rtype: nothing
+        """
+        self.inStack.append(x)
+
+    def pop(self):
+        """
+        :rtype: nothing
+        """
+        self.move()
+        return self.outStack.pop()
+
+    def peek(self):
+        """
+        :rtype: int
+        """
+        self.move()
+        return self.outStack[-1]
+
+    def empty(self):
+        """
+        :rtype: bool
+        """
+        return (not self.inStack) and (not self.outStack) 
+        
+    def move(self):
+        """
+        :rtype nothing
+        """
+        if not self.outStack:
+            while self.inStack:
+                self.outStack.append(self.inStack.pop())
+
+# Your MyQueue object will be instantiated and called as such:
+# obj = MyQueue()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.peek()
+# param_4 = obj.empty()
+
diff --git a/StackAndQueue/Kilien/242.valid-anagram.py b/StackAndQueue/Kilien/242.valid-anagram.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d0f49d00f28fefa862434011d65eecc079654ce
--- /dev/null
+++ b/StackAndQueue/Kilien/242.valid-anagram.py
@@ -0,0 +1,33 @@
+# @Author：Kilien
+# @lc app=leetcode id=242 lang=python3
+#
+# [242] Valid Anagram
+#
+class Solution:
+
+# 思路：数组排序后比较差异
+#    def isAnagram(self, s: str, t: str) -> bool:
+#        return sorted(s) == sorted(t)
+
+# 思路：手动模拟hashtable，将字符串”a-z“的ASCII码作key，计数求差异
+    def isAnagram(self, s: str, t: str) -> bool:
+        arr1, arr2 = [0]*26, [0]*26
+        for i in s:
+            arr1[ord(i) - ord('a')] += 1
+        for i in t:
+            arr2[ord(i) - ord('a')] += 1
+        return arr1 == arr2
+
+# 思路：map计数，对比计数差异
+"""
+    def isAnagram(self, s: str, t: str) -> bool:
+        dict1, dict2 = {}, {}
+        for item in s:
+            dict1[item] = dict1.get(item,0) + 1
+        for item in t:
+            dict2[item] = dict2.get(item,0) + 1
+        return dict1 == dict2
+"""
+
+
+
diff --git a/StackAndQueue/Kilien/703.kth-largest-element-in-a-stream.py b/StackAndQueue/Kilien/703.kth-largest-element-in-a-stream.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e50ad228cea99165d1a7e69d394832bf25f7d6f
--- /dev/null
+++ b/StackAndQueue/Kilien/703.kth-largest-element-in-a-stream.py
@@ -0,0 +1,29 @@
+# @Author:Kilien
+# @lc app=leetcode id=703 lang=python3
+#
+# [703] Kth Largest Element in a Stream
+# 思路：将列表转化为小顶堆，保证第k个大的元素在堆顶，
+# 若堆中元素个数小于k，则后续元素入堆，重新排序，直至堆满足k个元素
+# 若后续加入元素比堆顶大则剔除堆顶元素，该元素加入小顶堆，重新排序
+# 若后续加入元素比堆顶小则忽略
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.pool = nums
+        self.k = k
+        heapq.heapify(self.pool)
+        while len(self.pool) > k:
+            heapq.heappop(self.pool)
+
+    def add(self, val: int) -> int:
+        if len(self.pool) < self.k:
+            heapq.heappush(self.pool, val)
+        elif val > self.pool[0]:
+            heapq.heapreplace(self.pool, val)
+        return self.pool[0]
+
+
+# Your KthLargest object will be instantiated and called as such:
+# obj = KthLargest(k, nums)
+# param_1 = obj.add(val)
+
diff --git a/StackAndQueue/Kilien/Implement Queue using Stacks.jpg b/StackAndQueue/Kilien/Implement Queue using Stacks.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d243b156856c1db1a1c0f18dc295a264fed9ebab
Binary files /dev/null and b/StackAndQueue/Kilien/Implement Queue using Stacks.jpg differ
diff --git a/StackAndQueue/Kilien/Implement Stack using Queues.jpg b/StackAndQueue/Kilien/Implement Stack using Queues.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e181993eb094652131e11397b4b8431b3defb184
Binary files /dev/null and b/StackAndQueue/Kilien/Implement Stack using Queues.jpg differ
diff --git a/StackAndQueue/Kilien/Kth Largest Element in a Stream.jpg b/StackAndQueue/Kilien/Kth Largest Element in a Stream.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6e52089305a8cd7c0127682963c6d716524f9011
Binary files /dev/null and b/StackAndQueue/Kilien/Kth Largest Element in a Stream.jpg differ
diff --git a/StackAndQueue/Kilien/Valid Anagram.jpg b/StackAndQueue/Kilien/Valid Anagram.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..124924365e71e097608a816cbe051d5afd6bc82c
Binary files /dev/null and b/StackAndQueue/Kilien/Valid Anagram.jpg differ
diff --git a/StackAndQueue/Kilien/Valid Parentheses.jpg b/StackAndQueue/Kilien/Valid Parentheses.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..9ae219a1bcd17e0bec956f2b665d48b8247d2a78
Binary files /dev/null and b/StackAndQueue/Kilien/Valid Parentheses.jpg differ
diff --git a/Tree/Kilien/144.binary-tree-preorder-traversal.py b/Tree/Kilien/144.binary-tree-preorder-traversal.py
new file mode 100644
index 0000000000000000000000000000000000000000..da77aab7ea2669657bcd589b90708f8a75e9b26c
--- /dev/null
+++ b/Tree/Kilien/144.binary-tree-preorder-traversal.py
@@ -0,0 +1,35 @@
+# @Author:Kilien
+# @lc app=leetcode id=144 lang=python3
+#
+# [144] Binary Tree Preorder Traversal
+#
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+# recursiely
+class Solution:
+    def preorderTraversal(self, root: TreeNode) -> List[int]:
+        res = []
+        self.dfs(root, res)
+        return res
+    
+    def dfs(self, root, res):
+        if root:
+            res.append(root.val)
+            self.dfs(root.left, res)
+            self.dfs(root.right, res)
+
+# iteratively
+    def preorderTraversal(self, root: TreeNode) -> List[int]:
+        stack, res = [root], []
+        while stack:
+            node = stack.pop()
+            if node:
+                res.append(node.val)
+                stack.append(node.right)
+                stack.append(node.left)
+        return res      
+
diff --git a/Tree/Kilien/145.binary-tree-postorder-traversal.py b/Tree/Kilien/145.binary-tree-postorder-traversal.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b4d67eca320c7b58d6f37f8d69e29faa7e58313
--- /dev/null
+++ b/Tree/Kilien/145.binary-tree-postorder-traversal.py
@@ -0,0 +1,37 @@
+# @Author:Kilien
+# @lc app=leetcode id=145 lang=python3
+#
+# [145] Binary Tree Postorder Traversal
+#
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def postorderTraversal(self, root: TreeNode) -> List[int]:
+        res = []
+        self.dfs(root, res)
+        return res
+    
+    def dfs(self, root, res):
+        if root:
+            self.dfs(root.left, res)
+            self.dfs(root.right, res)       
+            res.append(root.val)
+
+# iteratively
+    def postorderTraversal(self, root: TreeNode) -> List[int]:
+        traversal, stack = [], [root]
+        while stack:
+            node = stack.pop()
+            if node:
+                # pre-order, right first
+                traversal.append(node.val)
+                stack.append(node.left)
+                stack.append(node.right)
+
+        # reverse result
+        return traversal[::-1]
diff --git a/Tree/Kilien/226.invert-binary-tree.py b/Tree/Kilien/226.invert-binary-tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..496a73e6bf653aca11445791a6522e6e128609c0
--- /dev/null
+++ b/Tree/Kilien/226.invert-binary-tree.py
@@ -0,0 +1,38 @@
+# @ Author:Kilien
+# @lc app=leetcode id=226 lang=python3
+#
+# [226] Invert Binary Tree
+#
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+# recursively
+class Solution:
+    def invertTree(self, root: TreeNode) -> TreeNode:
+        if root:
+            root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
+            return root
+
+# BFS            
+    def invertTree(self, root: TreeNode) -> TreeNode:
+        queue = collections.deque([(root)])
+        while queue:
+            node = queue.popleft()
+            if node:
+                node.left, node.right = node.right, node.left
+                queue.append(node.left)
+                queue.append(node.right)
+        return root
+
+# DFS
+    def invertTree(self, root: TreeNode) -> TreeNode:
+        stack = [root]
+        while stack:
+            node = stack.pop()
+            if node:
+                node.left, node.right = node.right, node.left
+                stack.extend([node.right, node.left])
+        return root
diff --git a/Tree/Kilien/235.lowest-common-ancestor-of-a-binary-search-tree.py b/Tree/Kilien/235.lowest-common-ancestor-of-a-binary-search-tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..a558197b529109ac87e74212d7467e1892b49224
--- /dev/null
+++ b/Tree/Kilien/235.lowest-common-ancestor-of-a-binary-search-tree.py
@@ -0,0 +1,21 @@
+# @Author：Kilien
+# @lc app=leetcode id=235 lang=python3
+#
+# [235] Lowest Common Ancestor of a Binary Search Tree
+# 思路：根据BST的特性，左子树的值小于root，右子树的值大于root，递归遍历比较节点大小关系是否相符
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+# 
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if p.val < root.val > q.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        if p.val > root.val < q.val:
+            return self.lowestCommonAncestor(root.right, p, q)
+        return root
+
diff --git a/Tree/Kilien/236.lowest-common-ancestor-of-a-binary-tree.py b/Tree/Kilien/236.lowest-common-ancestor-of-a-binary-tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..06566da969f976a8b9ff3b8e4fbf4c7441cad78e
--- /dev/null
+++ b/Tree/Kilien/236.lowest-common-ancestor-of-a-binary-tree.py
@@ -0,0 +1,36 @@
+# @Author：Kilien
+# @lc app=leetcode id=236 lang=python3
+#
+# [236] Lowest Common Ancestor of a Binary Tree
+# 思路：
+# 先决条件：若root为空或者等于某个目标节点，返回root
+# Divide：遍历左右子树
+# Conquer：若左右子树皆有返回值，则root为最小公共祖先
+# 若只有左子树有返回值，则左子树的返回值为最小公共祖先
+# 若只有右子树有返回值，则右子树的返回值为最小公共祖先
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if root is None: 
+            return root
+        if root == p or root == q:
+            return root
+
+        #Divide
+        left = self.lowestCommonAncestor(root.left, p, q)
+        right = self.lowestCommonAncestor(root.right, p, q)
+
+        #Conquer
+        if left is None:
+            return right 
+        elif right is None:
+            return left 
+        else:
+            return root
+
diff --git a/Tree/Kilien/94.binary-tree-inorder-traversal.py b/Tree/Kilien/94.binary-tree-inorder-traversal.py
new file mode 100644
index 0000000000000000000000000000000000000000..82d9842001428b40794cd552d203cdd82c5fcb94
--- /dev/null
+++ b/Tree/Kilien/94.binary-tree-inorder-traversal.py
@@ -0,0 +1,36 @@
+# @Author:Kilien
+# @lc app=leetcode id=94 lang=python3
+#
+# [94] Binary Tree Inorder Traversal
+#
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def inorderTraversal(self, root: TreeNode) -> List[int]:
+        res = []
+        self.dfs(root, res)
+        return res
+    def dfs(self, root, res):
+        if root:
+            self.dfs(root.left, res)
+            res.append(root.val)
+            self.dfs(root.right, res)
+            
+
+# iteratively
+    def inorderTraversal(self, root: TreeNode) -> List[int]:
+        res, stack = [], []
+        while True:
+            while root:
+                stack.append(root)
+                root = root.left
+            if not stack:
+                return res
+            node = stack.pop()
+            res.append(node.val)
+            root = node.right
diff --git a/Tree/Kilien/98.validate-binary-search-tree.py b/Tree/Kilien/98.validate-binary-search-tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..e39384fb5e990da1f374c5128eb8cd9531f9d3d2
--- /dev/null
+++ b/Tree/Kilien/98.validate-binary-search-tree.py
@@ -0,0 +1,48 @@
+# @Author：Kilien
+# @lc app=leetcode id=98 lang=python3
+#
+# [98] Validate Binary Search Tree
+#
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+# 思路1：中序遍历，先遍历左子树，遍历后保留前一个节点的值（prev）；
+# prev节点与当前节点比较：
+# 若prev节点大于当前节点则非BST，否则当前节点赋值给prev，继续遍历右子树
+'''
+class Solution:
+    def isValidBST(self, root: TreeNode) -> bool:
+        self.prev = None
+        return self.inorder(root)
+    
+    def inorder(self, root):
+        if root is None:
+            return True
+        if not self.inorder(root.left):
+            return False
+        if self.prev and self.prev.val >= root.val:
+            return False
+        self.prev = root
+        return self.inorder(root.right)
+'''
+
+# 思路2：迭代法，设边界（Int最大值与最小值），递归比较左右子树是否合法
+import sys
+class Solution:
+    def isValidBST(self, root: TreeNode) -> bool:
+        return self.isValid(root, -sys.maxsize, sys.maxsize)
+    
+    def isValid(self, root, min, max):
+        if root is None:
+            return True
+        if min is None or root.val <= min:
+            return False
+        if max is None or root.val >= max:
+            return False
+        return self.isValid(root.left, min, root.val) and self.isValid(root.right, root.val, max)
+    
+