@@ -0,0 +1,27 @@
+class Solution:
+def preorder(self, root: 'Node') -> List[int]:
+self.res = []
+if not root: return self.res
+self.traverse(root)
+return self.res
+
+def traverse(self, node):
+if not node: return
+self.res.append(node.val)
+for child in node.children:
+self.traverse(child)
+
+class Solution2:
+def preorder(self, root: 'Node') -> List[int]:
+if root is None: return []
+
+stack = [root]
+output = []
+
+while stack:
+node = stack.pop()
+output.append(node.val)
+for i in range(len(node.children) - 1, -1, -1):
+stack.append(node.children[i])
+
+return output

@@ -0,0 +1,50 @@
+class Solution:
+def postorder(self, root: 'Node') -> List[int]:
+self.res = []
+if not root: return self.res
+self.traverse(root)
+return self.res
+
+def traverse(self, node):
+if not node: return
+
+for child in node.children:
+self.traverse(child)
+
+self.res.append(node.val)
+
+class Solution2:
+def postorder(self, root: 'Node') -> List[int]:
+res = []
+if not root: return res
+
+stack = [root]
+output = []
+while stack:
+node = stack.pop()
+if node:
+res.append(node.val)
+for child in node.children:
+stack.append(child)
+
+return res[::-1]
+
+class Solution3:
+def postorder(self, root: 'Node') -> List[int]:
+if not root: return []
+
+res = []
+stack1 = [root]
+stack2 = []
+
+while stack1:
+node = stack1.pop()
+stack2.append(node)
+for child in node.children:
+stack1.append(child)
+
+while stack2:
+val = stack2.pop().val
+res.append(val)
+
+return res

@@ -0,0 +1,20 @@
+from collections import deque
+
+class Solution:
+def levelOrder(self, root: 'Node') -> List[List[int]]:
+if not root: return []
+
+res = []
+q = deque()
+q.append(root)
+
+while q:
+level = []
+for _ in range(len(q)):
+node = q.popleft()
+level.append(node.val)
+for child in node.children:
+q.append(child)
+res.append(level)
+
+return res

@@ -0,0 +1,31 @@
+class Solution:
+def maxDepth(self, root: 'Node') -> int:
+if not root: return 0
+
+self.max_depth = 1
+self.traverse(root, 1)
+return self.max_depth
+
+def traverse(self, node, depth):
+if not node: return
+
+self.max_depth = max(depth, self.max_depth)
+for child in node.children:
+self.traverse(child, depth + 1)
+
+class Solution2:
+def maxDepth(self, root: 'Node') -> int:
+if not root: return 0
+
+stack = []
+stack.append((1, root))
+depth = 0
+
+while stack:
+cur_depth, node = stack.pop()
+if node:
+depth = max(cur_depth, depth)
+for child in node.children:
+stack.append((cur_depth + 1, child))
+
+return depth