@@ -0,0 +1,22 @@
+from collections import deque
+
+class Solution:
+def levelOrder(self, root):
+if not root: return None
+
+q = deque()
+q.append(root)
+res = []
+
+while q:
+level = []
+for _ in range(len(q)):
+node = q.popleft()
+level.append(node.val)
+if node.left:
+q.append(node.left)
+if node.right:
+q.append(node.right)
+res.append(level)
+
+return res

@@ -0,0 +1,26 @@
+from collections import deque
+
+class Solution:
+def levelOrderBottom(self, root):
+if not root: return None
+
+q = deque()
+q.append(root)
+stack = []
+res = []
+
+while q:
+level = []
+for _ in range(len(q)):
+node = q.popleft()
+level.append(node.val)
+if node.left:
+q.append(node.left)
+if node.right:
+q.append(node.right)
+stack.append(level)
+
+while stack:
+res.append(stack.pop())
+
+return res

@@ -0,0 +1,56 @@
+from collections import deque
+
+class Solution:
+def zigzagLevelOrder(self, root):
+if not root: return None
+
+q = deque()
+q.append(root)
+res = []
+l_to_r = True
+
+while q:
+level = deque()
+for _ in range(len(q)):
+node = q.popleft()
+
+if l_to_r:
+level.append(node.val)
+else:
+level.appendleft(node.val)
+
+if node.left:
+q.append(node.left)
+if node.right:
+q.append(node.right)
+
+res.append(level)
+l_to_r = not l_to_r
+
+return res
+
+from collections import deque
+
+class Solution2:
+def zigzagLevelOrder(self, root):
+if not root: return None
+
+q = deque()
+q.append(root)
+direction = 1
+res = []
+
+while q:
+level = [node.val for node in list(q)[::direction]]
+
+for _ in range(len(q)):
+node = q.popleft()
+if node.left:
+q.append(node.left)
+if node.right:
+q.append(node.right)
+
+res.append(level)
+direction *= -1
+
+return res

@@ -0,0 +1,23 @@
+from collections import deque
+
+class Solution:
+def averageOfLevels(self, root):
+if not root: return None
+
+q = deque()
+q.append(root)
+res = []
+
+while q:
+total = 0
+count = len(q)
+for _ in range(len(q)):
+node = q.popleft()
+total += node.val
+if node.left:
+q.append(node.left)
+if node.right:
+q.append(node.right)
+res.append(total / count)
+
+return res

@@ -0,0 +1,22 @@
+from collections import deque
+
+class Solution:
+def minDepth(self, root):
+if not root: return 0
+
+q = deque()
+q.append(root)
+levels = 1
+
+while q:
+for _ in range(len(q)):
+node = q.popleft()
+if not node.left and not node.right:
+return levels
+if node.left:
+q.append(node.left)
+if node.right:
+q.append(node.right)
+levels += 1
+
+return levels

@@ -0,0 +1,10 @@
+class Solution:
+def hasPathSum(self, root, sum):
+if not root: return False
+
+new_sum = sum - root.val
+if not root.left and not root.right:
+return new_sum == 0
+
+return (self.hasPathSum(root.left, new_sum)
+or self.hasPathSum(root.right, new_sum))

@@ -0,0 +1,17 @@
+class Solution:
+def pathSum(self, root, sum):
+self.res = []
+self.traverse(root, sum, [])
+return self.res
+
+def traverse(self, root, sum, path):
+if not root: return
+
+sum -= root.val
+path.append(root.val)
+if not root.left and not root.right and sum == 0:
+self.res.append(path.copy())
+else:
+self.traverse(root.left, sum, path)
+self.traverse(root.right, sum, path)
+path.pop()

@@ -0,0 +1,15 @@
+class Solution:
+def sumRootToLeaf(self, root):
+self.total = 0
+self.traverse(root, 0)
+return self.total
+
+def traverse(self, root, pathSum):
+if not root: return
+
+pathSum = (pathSum << 1) | root.val
+if root.left is None and root.right is None:
+self.total += pathSum
+else:
+self.traverse(root.left, pathSum)
+self.traverse(root.right, pathSum)

@@ -0,0 +1,41 @@
+class Solution:
+def pathSum(self, root, sum):
+return self.traverse(root, sum, [])
+
+def traverse(self, node, target, path):
+if node is None: return 0
+
+path.append(node.val)
+pathSum = 0
+pathCount = 0
+for i in range(len(path)-1, -1, -1):
+pathSum += path[i]
+if pathSum == target:
+pathCount += 1
+
+pathCount += self.traverse(node.left, target, path)
+pathCount += self.traverse(node.right, target, path)
+
+path.pop()
+return pathCount
+
+class Solution2:
+def pathSum(self, root, sum):
+self.count = 0
+self.cache = {0: 1}
+self.dfs(root, 0, sum)
+return self.count
+
+def dfs(self, node, cur_sum, sum):
+if not node: return
+
+cur_sum += node.val
+if cur_sum - sum in self.cache:
+self.count += self.cache[cur_sum - sum]
+
+self.cache[cur_sum] = self.cache.get(cur_sum, 0) + 1
+
+self.dfs(node.left, cur_sum, sum)
+self.dfs(node.right, cur_sum, sum)
+
+self.cache[cur_sum] -= 1