improve solution

Author: delight010

construct-binary-tree-from-preorder-and-inorder-traversal/delight010.swift

@@ -1,13 +1,16 @@
 class Solution {
-    // Time O(N)
+    // Time O(N^2)
     // Space O(N)
     func buildTree(_ preorder: [Int], _ inorder: [Int]) -> TreeNode? {
+        return buildTree(preorder[...], inorder[...])
+    }
+    
+    func buildTree(_ preorder: ArraySlice<Int>, _ inorder: ArraySlice<Int>) -> TreeNode? {
         if preorder.isEmpty {
             return nil
         }
 
-        let totalCount = preorder.count
-        let rootNode = TreeNode(preorder[0])
+        let rootNode = TreeNode(preorder.first!)
         var rootIndex = 0
 
         for (index, value) in inorder.enumerated() {
@@ -16,9 +19,8 @@ class Solution {
                 break
             }
         }
-        
-        rootNode.left = buildTree(Array(preorder[1..<rootIndex + 1]), Array(inorder[0..<rootIndex + 1]))
-        rootNode.right = buildTree(Array(preorder[1 + rootIndex..<totalCount]), Array(inorder[1 + rootIndex..<totalCount]))
+        rootNode.left = buildTree(preorder[preorder.startIndex + 1..<preorder.startIndex + rootIndex + 1], inorder[inorder.startIndex..<inorder.startIndex + rootIndex])
+        rootNode.right = buildTree(preorder[preorder.startIndex + 1 + rootIndex..<preorder.endIndex], inorder[inorder.startIndex + 1 + rootIndex..<inorder.endIndex])
 
         return rootNode
     }

subtree-of-another-tree/delight010.swift

@@ -1,29 +1,20 @@
 class Solution {
     // Time O(M * N)
-    // Space O(N)
+    // Space O(M + N)
     func isSubtree(_ root: TreeNode?, _ subRoot: TreeNode?) -> Bool {
         if let root = root, let subRoot = subRoot {
-            if root.val == subRoot.val {
-                return dfs(root.left, subRoot: subRoot.left) && dfs(root.right, subRoot: subRoot.right) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot)
-            }
-            return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot)
+            return dfs(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot)
         }
 
-        return false
+        return root == nil && subRoot == nil
     }
 
     private func dfs(_ root: TreeNode?, subRoot: TreeNode?) -> Bool {
-        if root == nil && subRoot == nil {
-            return true
-        }
-        
         if let root = root, let subRoot = subRoot {
-            if root.val == subRoot.val {
-                return dfs(root.left, subRoot: subRoot.left) && dfs(root.right, subRoot: subRoot.right)
-            }
+            return root.val == subRoot.val && dfs(root.left, subRoot.left) && dfs(root.right, subRoot.right)
         }
 
-        return false
+        return root == nil && subRoot == nil
     }
 }