*Tim discusses using Swift enumeration indirect keywords to build binary tree nodes. Read on to learn more about how reference types and value semantics combine…*

Today we’re writing a simple binary search tree in Swift. While binary search trees seem to be very powerful in theory, their performance is rather disappointing in practice. Other, more advanced tree-shaped data structures such as red-black trees and B-trees solve some of the practical problems that binary search trees have, and are subsequently much more useful in performance-critical code. Nevertheless, learning about binary search trees is the first step to getting more familiar with this class of data structures.

Probably the simplest way to represent a binary tree in Swift is by using an indirect enum, like so:

enum BinarySearchTree<Element: Comparable> { case empty indirect case node(left: BinarySearchTree, value: Element, right: BinarySearchTree) }

While indirect enums use reference types under the hood, they have value semantics by default. So that’s nice.

From all the standard library’s protocols, `SetAlgebra`

and `BidirectionalCollection`

both seem a good fit for our `BinarySearchTree`

type: `SetAlgebra`

for inserting and removing elements, and `BidirectionalCollection`

for traversing the tree (both forwards and backwards, hence the name). However, for the purpose of this post, we’ll stick to only a couple basic methods.

Let’s start with insertion. Because of the way enums with associated values work, it’s easiest to implement the `insert`

method using an under-the-hood `inserting`

method:

extension BinarySearchTree { mutating func insert(_ element: Element) { self = inserting(element) } private func inserting(_ element: Element) -> BinarySearchTree { switch self { case .empty: // the tree is empty, so inserting an element results in a tree containing only that element return .node(.empty, element, .empty) case .node(_, element, _): // the element is already present in the tree return self case let .node(left, value, right) where element < value: // the element should be inserted into the left subtree return .node(left.inserting(element), value, right) case let .node(left, value, right): // the element should be inserted into the right subtree return .node(left, value, right.inserting(element)) } } }

Now we can insert values into a tree, but we can’t read them in any way. So let’s add a `contains`

method as well:

extension BinarySearchTree { func contains(_ element: Element) -> Bool { switch self { case .empty: // an empty tree obviously doesn't contain any elements! return false case .node(_, element, _): // the element is equal to this node's value return true case let .node(left, value, _) where element < value: // if the element is present in the tree, it must be in the left subtree return left.contains(element) case let .node(_, _, right): // if the element is present in the tree, it must be in the right subtree return right.contains(element) } } }

Let’s try it out!

var tree = BinarySearchTree.empty tree.contains(5) // => false tree.insert(5) tree.contains(5) // => true tree.insert(3) tree.contains(3) // => true tree.contains(5) // => true

Looks good. We can’t actually remove elements, though, but that is a real pain to implement and it’s out of scope for this post.

Finally, to iterate over a binary search tree, we need to implement the `IteratorProtocol`

protocol. We’ll use an in-order traversal algorithm:

extension BinarySearchTree: Sequence { func makeIterator() -> BinarySearchTreeIterator<Element> { return BinarySearchTreeIterator(self) } } struct BinarySearchTreeIterator<Element: Comparable>: IteratorProtocol { var node: BinarySearchTree var stack: [(Element, BinarySearchTree)] = [] init(_ node: BinarySearchTree) { self.node = node } public mutating func next() -> Element? { while case let .node(left, value, right) = node { stack.append((value, right)) node = left } guard let (element, node) = stack.popLast() else { return nil } self.node = node return element } }

Now we can do all kinds of sequence-y stuff with trees, like so:

var tree = BinarySearchTree.empty [5, 2, 4, 8, 3, 2].forEach { tree.insert($0) } for element in tree { print(element, terminator: " ") // => 2 3 4 5 8 } tree.reduce(0, +) // => 22 tree.lazy.map(String.init).joined(separator: ", ") // => 2, 3, 4, 5, 8

And the list goes on.

That’s it for now! If you enjoy this kind of stuff, make sure to check out Károly Lőrentey’s brand new book Optimizing Collections in which he in much detail goes through implementing several data structures in Swift, focusing on performance. As of writing this post, it’s 25% off.

## One Comment

Thank you for this post! This leads to a question whose answer I would find very useful. How would you write a class MarkovChain or TransitionTable in idiomatic Swift that takes a transition table like

A B C

A 0.1 0.6 0.3

B 0.2 0.0 0.8

C 0.2 0.6 0.2

(except the actual transition table will be quite a lot larger (16 x 16?), like two pre-calculated transition tables of “all the intervals in a McCartney song” and “all the intervals in a Lennon song”, with the app modulating along a linear curve from McCartney-esque to Lennon-esque and back)

(probably using the sums to make it easier):

A B C

A 0.1 0.7 1.0

B 0.2 0.2 1.0

C 0.2 0.8 1.0

then, given a current row and a new random number between 0.0 and 1.0

func transition(String currentRow, double rand) -> String

returns the next row (“A”, “B”, “C”), where “A” might point to “major tenth down”, “B” to “minor tenth down”, etc. The problem is making it as fast as possible, using binary search and anything else available.

Thanks!