Implemented isEmpty and elements properties, contains(element:, tree) -> Bool and constructEmpty() -> BinaryTree static methods, refactored the data structure and added usage examples

Author: eleev

Data Structures.playground/Pages/BinaryTree.xcplaygroundpage/Contents.swift

@@ -2,9 +2,14 @@
 
 import Foundation
 
-indirect enum BinaryTree<T> {
+ enum BinaryTree<T> where T : Comparable {
+    
+    // MARK: - Cases
+    
     case empty
-    case node(BinaryTree, T, BinaryTree)
+    indirect case node(BinaryTree, T, BinaryTree)
+    
+    // MARK: - Properties
 
     var count: Int {
         switch self {
@@ -14,6 +19,45 @@ indirect enum BinaryTree<T> {
             return 0
         }
     }
+    
+    var isEmpty: Bool {
+        switch self {
+        case .empty:
+            return true
+        case .node(_, _, _):
+            return false
+        }
+    }
+    
+    var elements: [T] {
+        switch self {
+        case .empty:
+            return []
+        case .node(let left, let element, let right):
+            return left.elements + [element] + right.elements
+        }
+    }
+    
+    // MARK: - Static methods
+    
+    static func contains(element: T, tree: BinaryTree<T>) -> Bool {
+        switch tree {
+        case .empty:
+            return false
+        case .node(let left, let item, let right):
+            if element < item {
+                return contains(element: element, tree: left)
+            } else if element > item {
+                return contains(element: element, tree: right)
+            }
+            return true
+        }
+    }
+    
+    
+    static func constructEmpty() -> BinaryTree {
+        return .empty
+    }
 }
 
 //: There are several ways how Binary Trees can be constructed. Classic approach is to use reference types e.g. classes. The implementation is pretty similar to the Tree data structure that is implemented in this playground file. However we used a different approach - value types... well sort of. Swift has several value types: structures (aka struct) and enumeration types (aka enum). In Swift enumeration type has many cool features and their practical application usage is far more extended and advanced in comparison to Java or Objective C for example. You may think that it sounds a bit weird... and you will be right. Value types have fixed size, meaning that compiler knows in advance the size of a struct or enum type. However when building recursion compiler does not have information about the size of the type. The last two mentioned conditions contradict each other, so we need to tell the compiler about our intentions. Swift has such mechanims and a special keyword called `indirect`. `Indirect` keyword introduces a layer of indirection behind the scenes which allows us to use value cases or whole enumeration types recursiveley. You need to note that this keyword only works with enums. Structs do not support this feature.
@@ -64,6 +108,14 @@ let finalTree = BinaryTree.node(tree2, "+", treeMult)
 
 print(finalTree)
 
+let containsThree = BinaryTree.contains(element: "3", tree: finalTree)
+print(containsThree)
+
+let containsFour = BinaryTree.contains(element: "4", tree: finalTree)
+print(containsFour)
+
+let treeElementsArray = finalTree.elements
+print(treeElementsArray)
 
 //: In order to properly construct Binary Tree you need to start building the tree by layers. The means the first thing you need to do is to draw the tree and split every single operation into separate layer. Multiplying 5 and 3 is the first operation that happens, that is why we compose this operation separately and form a Binary Tree node separately. Then we define 2 as a separate leaf node and add it to the first layer, which results into a final tree node that contains all the nodes.