Swift implementation of Binary Search Tree

BSTree.swift

import Foundation

class Node {
    var val: Int
    
    var left: Node?
    
    var right: Node?
    
    init(val: Int) {
        self.val = val
    }
}

class BSTree {
    var root: Node?
    
    func insert(val: Int) {
        if self.root == nil {
            self.root = Node(val: val)
        } else {
            self.insert(val: val, node: self.root!)
        }
    }
    
    func insert(val: Int, node: Node) {
        if val > node.val {
            if node.right == nil {
                node.right = Node(val: val)
            } else {
                self.insert(val: val, node: node.right!)
            }
        } else {
            if node.left == nil {
                node.left = Node(val: val)
            } else {
                self.insert(val: val, node: node.left!)
            }
        }
    }
    
    func contains(val: Int) -> Bool {
        return self.contains(val: val, node: self.root!)
    }
    
    func contains(val: Int, node: Node) -> Bool {
        if val == node.val {
            return true
        }
        
        if val > node.val && node.right != nil {
            return self.contains(val: val, node: node.right!)
        }
        
        if val < node.val && node.left != nil {
            return self.contains(val: val, node: node.left!)
        }
        
        return false
    }
    
    func preorder() {
        self.preorder(node: self.root!)
    }
    
    func preorder(node: Node) {
        print(node.val)
        if node.left != nil {
            preorder(node: node.left!)
        }
        if node.right != nil {
            preorder(node: node.right!)
        }
    }
    
    func inorder() {
        self.inorder(node: self.root!)
    }
    
    func inorder(node: Node) {
        if node.left != nil {
            inorder(node: node.left!)
        }
        print(node.val)

        if node.right != nil {
            inorder(node: node.right!)
        }
    }
}

let tree = BSTree()

tree.insert(val: 5)
tree.insert(val: 10)
tree.insert(val: 15)
tree.insert(val: 3)

tree.preorder()
tree.inorder()

tree.contains(val: 5)
tree.contains(val: 1)
tree.contains(val: 13)
tree.contains(val: 15)