Added solutions

Author: adityaramkumar

100.py

@@ -0,0 +1,17 @@
+# Runtime: 36 ms, faster than 91.77% of Python3 online submissions for Same Tree.
+# Difficulty: Easy
+
+class Solution:
+    def isSameTree(self, p, q):
+        """
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: bool
+        """
+        if p == None and q == None:
+            return True
+        elif p == None or q == None:
+            return False
+        elif p.val != q.val:
+            return False
+        return Solution.isSameTree(None, p.right, q.right) and Solution.isSameTree(None, p.left, q.left)

111.py

@@ -0,0 +1,19 @@
+# Runtime: 56 ms, faster than 74.98% of Python3 online submissions for Minimum Depth of Binary Tree.
+# Difficulty: Easy
+
+class Solution:
+    def minDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if root == None:
+            return 0
+        elif root.left == None and root.right != None:
+            return 1 + Solution.minDepth(self, root.right)
+        elif root.left != None and root.right == None:
+            return 1 + Solution.minDepth(self, root.left)
+        elif root.left == None and root.right == None:
+            return 1
+        elif root.left != None and root.right != None:
+            return 1 + min(Solution.minDepth(self, root.left), Solution.minDepth(self, root.right))

226.py

@@ -0,0 +1,15 @@
+# Runtime: 36 ms, faster than 95.98% of Python3 online submissions for Invert Binary Tree.
+# Difficulty: Easy
+
+class Solution:
+    def invertTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: TreeNode
+        """
+        if root == None:
+            return None
+        t = TreeNode(root.val)
+        t.left = Solution.invertTree(None, root.right) 
+        t.right = Solution.invertTree(None, root.left) 
+        return t

257.py

@@ -0,0 +1,21 @@
+# Runtime: 44 ms, faster than 59.47% of Python3 online submissions for Binary Tree Paths.
+# Difficulty: Easy
+
+class Solution:
+    def binaryTreePaths(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[str]
+        """
+        paths = list()
+        if root == None:
+            return paths
+        if root.right == None and root.left == None:
+            return [str(root.val)]
+        if root.left != None:
+            for path in Solution.binaryTreePaths(None, root.left):
+                paths.append(str(root.val) + '->' + path)
+        if root.right != None:
+            for path in Solution.binaryTreePaths(None, root.right):
+                paths.append(str(root.val) + '->' + path)
+        return paths

637.py

@@ -0,0 +1,25 @@
+# Runtime: 92 ms, faster than 22.01% of Python3 online submissions for Average of Levels in Binary Tree.
+# Difficulty: Easy
+
+class Solution:
+    def averageOfLevels(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[float]
+        """
+        values = list()
+        def helper(tree, level):
+            if tree == None:
+                return
+            if len(values) <= level:
+                values.append([tree.val])
+            else:
+                values[level].append(tree.val)
+            helper(tree.left, level + 1)
+            helper(tree.right, level + 1)
+                
+        helper(root, 0)
+        averages = list()
+        for value in values:
+            averages.append(sum(value) / len(value))
+        return averages

814.py

@@ -0,0 +1,19 @@
+# Runtime: 40 ms, faster than 58.20% of Python3 online submissions for Binary Tree Pruning.
+# Difficulty: Medium
+
+class Solution:
+    def pruneTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: TreeNode
+        """
+        def contains_one(tree):
+            if tree == None:
+                return False
+            return any([contains_one(b) for b in [tree.right, tree.left]] + [tree.val == 1])
+        
+        if contains_one(root):
+            t = TreeNode(root.val)
+            t.left = Solution.pruneTree(None, root.left)
+            t.right = Solution.pruneTree(None, root.right)
+            return t

94.py

@@ -0,0 +1,16 @@
+# Runtime: 36 ms, faster than 96.42% of Python3 online submissions for Binary Tree Inorder Traversal.
+# Difficulty: Medium
+
+class Solution:
+    def inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        lst = list()
+        if root == None:
+            return []
+        lst.extend(Solution.inorderTraversal(None, root.left))
+        lst.append(root.val)
+        lst.extend(Solution.inorderTraversal(None, root.right))
+        return lst