I have often been asked, “What is the most memorable bug that you have encountered in your testing career?” For me, it is hands down a bug that happened quite a few years ago. I was leading an Engineering Productivity team that supported Google App Engine. At that time App Engine was still in its early stages, and there were many challenges associated with testing rapidly evolving features. Our testing frameworks and processes were also evolving, so it was an exciting time to be on the team. 
What makes this bug so memorable is that I spent so much time developing a comprehensive suite of test scenarios, yet a failure occurred during such an obvious use case that it left me shaking my head and wondering how I had missed it. Even with many years of testing experience it can be very humbling to construct scenarios that adequately mirror what will happen in the field.
I’ll try to provide enough background for the reader to play along and see if they can determine the anomalous scenario. As a further hint, the problem resulted from the interaction of two App Engine features, so I like calling this story A Tale of Two Features.

Feature 1 – Datastore Admin (backup, restore, delete)

Google App Engine was released 13 years ago as Google’s first Cloud product. It allowed users to build and deploy highly scalable web applications in the Cloud. To support this, it had its own scalable database called the Datastore. An administration console allowed users to manage the application and its Datastore through a web interface. Users wrote applications that consisted of request handlers that App Engine invoked according to the URL that was specified. The handlers could call App Engine services like Datastore through a remote procedure call (RPC) mechanism. Figure 1 illustrates this flow.

The first feature in this Tale of Two Features resided in the administration console, providing the ability to back up, restore, and delete selected or all of an application’s entities in the Datastore. It was implemented in a clever way that incorporated it directly into the application, rather than as an independent utility. As part of the application it could freely operate on the Datastore and incur the same billing charges as other datastore operations within the application. When the feature was invoked, traffic would be sent to its handler and the application would process it. Figure 2 illustrates this request flow.

By the time this memorable bug occurred, this Datastore administration feature was mature, well tested, and stable. No changes were being made to it.

Feature 2 – Utilities for Migrating to the HR – Datastore

The second feature (or more accurately, set of features) came at least a year after the first feature was released and stable. It helped users migrate their applications to a new High Replication (HR) Datastore. The HR Datastore was more reliable than its predecessor, but using it meant creating a new application and copying over all the data from the old Datastore. To support such migrations, App Engine developers added two new features to the administration console. The first copied all the data from the Datastore of one application to another, and the second redirected all traffic from one application to another. The latter was particularly useful because it meant the new application would seamlessly receive the traffic after a migration. This set of features was written by another team, and we in Engineering Productivity supported them by creating processes for testing various Datastore migrations. The migration-support features were thoroughly tested and released to developers. Figure 3 illustrates the request flow of the redirection feature.

What Could Possibly Go Wrong?

So this was the situation when we released these utilities for migrating to the new Datastore. We were very confident that they worked, as we had tested migrations of many different types and sizes of Datastore entities. We had also tested that a migration could be interrupted without data loss. All checked out fine. I was confident that this new feature would work, yet soon after we released it, we started getting problem reports.
If you have been playing along, now is the time to ask yourself,  “What could possibly go wrong?” As an added hint, the problem reports claimed that all the data in the newly migrated application was disappearing.

What Did Go Wrong

As mentioned above, developers began to report that data was disappearing from their newly migrated applications. It wasn’t at all common, yet of course it is most disconcerting when data “just disappears.” We had to investigate how this could occur. Our standard processes ensured that we had internal backups of the data, which were promptly restored. In parallel we tried to reproduce the problem, but we couldn’t—at least until we figured out what was happening. As I mentioned earlier, once we understood it, it was quite obvious, but that only made it all the more painful that we missed it.
What was happening was that, after migrating and automatically redirecting traffic to the new application, a number of customers thought they still needed to delete the data from their old application, so they used the first Datastore admin feature to do that. As expected, the feature sent traffic to that application to delete the entities from the Datastore. But that traffic was now being automatically redirected to the new application, and voila—all the data that had been copied earlier was now deleted there. Since only a handful of developers tried to delete the data from their old applications, this explained why the problem occurred only rarely. Figure 4 illustrates this request flow.

Obvious, isn’t it, once you know what is happening.

Lessons Learned

This all occurred years ago, and App Engine is based on a far different and more robust framework today. Datastore migrations are but a memory from the past, yet this experience made a great impression on me.
The most important thing I learned from this experience is that, while it is important to test features for their functionality, it’s also important to think of them as part of workflows. In performing our testing we exercised a very limited number of steps in the migration process workflow and omitted a very reasonable step at the end: trying to delete the data from the old application. Our focus was in testing the variability of contents in the Datastore rather than different steps in the migration process. It was this focus that kept our eyes away from the relatively obvious failure case.
Another thing I learned was that this bug might have been caught if the developer of the first feature had been in the design review for the second set of migration features (particularly the feature that automatically redirects traffic). Unfortunately, that person had already joined a new team. A key step in reducing bugs can occur at the design stage if “what-if” questions are being asked.
Finally, I was enormously impressed that we were able to recover so quickly. Protecting against data loss is one of the most important aspects of Cloud management, and being able to recover from mistakes is at least as important as trying to prevent them. I have the utmost respect for my coworkers in Site Reliability Engineering (SRE).

References

An Overview of Google App Engine

A Tale of Two Features

1. Only one disk may be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack or on an empty rod.
3. No disk may be placed on top of a disk that is smaller than it.

Prints n moves in the Tower of Hanoi puzzle.

func tower_of_hanoi(_ n: Int) -> [[Int]] {
    var result: [[Int]] = []
    
    func helper(_ n: Int, _ src: Int, _ aux: Int, _ dst: Int) {
        if n == 1  {
            result.append([src, dst])
            return
        }
        
        helper(n - 1, src, dst, aux)
        result.append([src, dst])
        helper(n - 1, aux, src, dst)
    }
    
    helper(n, 1, 2, 3)
    
    return result
}

print(tower_of_hanoi(3))

https://github.com/apple/swift-collections/blob/main/Sources/DequeModule/Deque.swift

@frozen
public struct Heap {
  @usableFromInline
  internal var _storage: ContiguousArray

  @inlinable
  public init() {
    _storage = []
  }
}

#if swift(>=5.5)
extension Heap: Sendable where Element: Sendable {}
#endif

extension Heap {
  @inlinable @inline(__always)
  public var isEmpty: Bool {
    _storage.isEmpty
  }

  @inlinable @inline(__always)
  public var count: Int {
    _storage.count
  }

  @inlinable
  public var unordered: [Element] {
    Array(_storage)
  }

  @inlinable
  public mutating func insert(_ element: Element) {
    _storage.append(element)

    _update { handle in
      handle.bubbleUp(_Node(offset: handle.count - 1))
    }
    _checkInvariants()
  }

  @inlinable
  public func min() -> Element? {
    _storage.first
  }

  @inlinable
  public func max() -> Element? {
    _storage.withUnsafeBufferPointer { buffer in
      guard buffer.count > 2 else {
        return buffer.last
      }
      return Swift.max(buffer[1], buffer[2])
    }
  }

  @inlinable
  public mutating func popMin() -> Element? {
    guard _storage.count > 0 else { return nil }

    var removed = _storage.removeLast()

    if _storage.count > 0 {
      _update { handle in
        let minNode = _Node.root
        handle.swapAt(minNode, with: &removed)
        handle.trickleDownMin(minNode)
      }
    }

    _checkInvariants()
    return removed
  }

  @inlinable
  public mutating func popMax() -> Element? {
    guard _storage.count > 2 else { return _storage.popLast() }

    var removed = _storage.removeLast()

    _update { handle in
      if handle.count == 2 {
        if handle[.leftMax] > removed {
          handle.swapAt(.leftMax, with: &removed)
        }
      } else {
        let maxNode = handle.maxValue(.rightMax, .leftMax)
        handle.swapAt(maxNode, with: &removed)
        handle.trickleDownMax(maxNode)
      }
    }

    _checkInvariants()
    return removed
  }

  @inlinable
  public mutating func removeMin() -> Element {
    return popMin()!
  }

  @inlinable
  public mutating func removeMax() -> Element {
    return popMax()!
  }

  @inlinable
  @discardableResult
  public mutating func replaceMin(with replacement: Element) -> Element {
    precondition(!isEmpty, "No element to replace")

    var removed = replacement
    _update { handle in
      let minNode = _Node.root
      handle.swapAt(minNode, with: &removed)
      handle.trickleDownMin(minNode)
    }
    _checkInvariants()
    return removed
  }

  @inlinable
  @discardableResult
  public mutating func replaceMax(with replacement: Element) -> Element {
    precondition(!isEmpty, "No element to replace")

    var removed = replacement
    _update { handle in
      switch handle.count {
      case 1:
        handle.swapAt(.root, with: &removed)
      case 2:
        handle.swapAt(.leftMax, with: &removed)
        handle.bubbleUp(.leftMax)
      default:
        let maxNode = handle.maxValue(.leftMax, .rightMax)
        handle.swapAt(maxNode, with: &removed)
        handle.bubbleUp(maxNode)
        handle.trickleDownMax(maxNode)
      }
    }
    _checkInvariants()
    return removed
  }
}

extension Heap {
  
  @inlinable
  public init(_ elements: S) where S.Element == Element {
    _storage = ContiguousArray(elements)
    guard _storage.count > 1 else { return }

    _update { handle in
      handle.heapify()
    }
    _checkInvariants()
  }

  @inlinable
  public mutating func insert(
    contentsOf newElements: S
  ) where S.Element == Element {
    if count == 0 {
      self = Self(newElements)
      return
    }
    _storage.reserveCapacity(count + newElements.underestimatedCount)
    for element in newElements {
      insert(element)
    }
  }
}

@usableFromInline @frozen
internal struct _Node {
  @usableFromInline
  internal var offset: Int

  @usableFromInline
  internal var level: Int

  @inlinable
  internal init(offset: Int, level: Int) {
    assert(offset >= 0)
#if COLLECTIONS_INTERNAL_CHECKS
    assert(level == Self.level(forOffset: offset))
#endif
    self.offset = offset
    self.level = level
  }

  @inlinable
  internal init(offset: Int) {
    self.init(offset: offset, level: Self.level(forOffset: offset))
  }
}

extension _Node: Comparable {
  @inlinable @inline(__always)
  internal static func ==(left: Self, right: Self) -> Bool {
    left.offset == right.offset
  }

  @inlinable @inline(__always)
  internal static func <(left: Self, right: Self) -> Bool {
    left.offset < right.offset
  }
}

extension _Node: CustomStringConvertible {
  @usableFromInline
  internal var description: String {
    "(offset: \(offset), level: \(level))"
  }
}

extension _Node {
  @inlinable @inline(__always)
  internal static func level(forOffset offset: Int) -> Int {
    (offset &+ 1)._binaryLogarithm()
  }

  @inlinable @inline(__always)
  internal static func firstNode(onLevel level: Int) -> _Node {
    assert(level >= 0)
    return _Node(offset: (1 &<< level) &- 1, level: level)
  }

  @inlinable @inline(__always)
  internal static func lastNode(onLevel level: Int) -> _Node {
    assert(level >= 0)
    return _Node(offset: (1 &<< (level &+ 1)) &- 2, level: level)
  }

  @inlinable @inline(__always)
  internal static func isMinLevel(_ level: Int) -> Bool {
    level & 0b1 == 0
  }
}

extension _Node {
  @inlinable @inline(__always)
  internal static var root: Self {
    Self.init(offset: 0, level: 0)
  }

  @inlinable @inline(__always)
  internal static var leftMax: Self {
    Self.init(offset: 1, level: 1)
  }

  @inlinable @inline(__always)
  internal static var rightMax: Self {
    Self.init(offset: 2, level: 1)
  }

  @inlinable @inline(__always)
  internal var isMinLevel: Bool {
    Self.isMinLevel(level)
  }

  @inlinable @inline(__always)
  internal var isRoot: Bool {
    offset == 0
  }
}

extension _Node {
  @inlinable @inline(__always)
  internal func parent() -> Self {
    assert(!isRoot)
    return Self(offset: (offset &- 1) / 2, level: level &- 1)
  }

  @inlinable @inline(__always)
  internal func grandParent() -> Self? {
    guard offset > 2 else { return nil }
    return Self(offset: (offset &- 3) / 4, level: level &- 2)
  }

  @inlinable @inline(__always)
  internal func leftChild() -> Self {
    Self(offset: offset &* 2 &+ 1, level: level &+ 1)
  }

  @inlinable @inline(__always)
  internal func rightChild() -> Self {
    Self(offset: offset &* 2 &+ 2, level: level &+ 1)
  }

  @inlinable @inline(__always)
  internal func firstGrandchild() -> Self {
    Self(offset: offset &* 4 &+ 3, level: level &+ 2)
  }

  @inlinable @inline(__always)
  internal func lastGrandchild() -> Self {
    Self(offset: offset &* 4 &+ 6, level: level &+ 2)
  }

  @inlinable
  internal static func allNodes(
    onLevel level: Int,
    limit: Int
  ) -> ClosedRange? {
    let first = Self.firstNode(onLevel: level)
    guard first.offset < limit else { return nil }
    var last = self.lastNode(onLevel: level)
    if last.offset >= limit {
      last.offset = limit &- 1
    }
    return ClosedRange(uncheckedBounds: (first, last))
  }
}

extension ClosedRange where Bound == _Node {
  @inlinable @inline(__always)
  internal func _forEach(_ body: (_Node) -> Void) {
    assert(
      isEmpty || _Node.level(forOffset: upperBound.offset) == lowerBound.level)
    var node = self.lowerBound
    while node.offset <= self.upperBound.offset {
      body(node)
      node.offset &+= 1
    }
  }
}

extension Heap {
  #if COLLECTIONS_INTERNAL_CHECKS
  @inlinable
  @inline(never)
  internal func _checkInvariants() {
    guard count > 1 else { return }
    _checkInvariants(node: .root, min: nil, max: nil)
  }

  @inlinable
  internal func _checkInvariants(node: _Node, min: Element?, max: Element?) {
    let value = _storage[node.offset]
    if let min = min {
      precondition(value >= min,
                   "Element \(value) at \(node) is less than min \(min)")
    }
    if let max = max {
      precondition(value <= max,
                   "Element \(value) at \(node) is greater than max \(max)")
    }
    let left = node.leftChild()
    let right = node.rightChild()
    if node.isMinLevel {
      if left.offset < count {
        _checkInvariants(node: left, min: value, max: max)
      }
      if right.offset < count {
        _checkInvariants(node: right, min: value, max: max)
      }
    } else {
      if left.offset < count {
        _checkInvariants(node: left, min: min, max: value)
      }
      if right.offset < count {
        _checkInvariants(node: right, min: min, max: value)
      }
    }
  }
  #else
  @inlinable
  @inline(__always)
  public func _checkInvariants() {}
  #endif
}

extension Heap {
  @usableFromInline @frozen
  struct _UnsafeHandle {
    @usableFromInline
    var buffer: UnsafeMutableBufferPointer

    @inlinable @inline(__always)
    init(_ buffer: UnsafeMutableBufferPointer) {
      self.buffer = buffer
    }
  }

  @inlinable @inline(__always)
  mutating func _update(_ body: (_UnsafeHandle) -> R) -> R {
    _storage.withUnsafeMutableBufferPointer { buffer in
      body(_UnsafeHandle(buffer))
    }
  }
}

extension Heap._UnsafeHandle {
  @inlinable @inline(__always)
  internal var count: Int {
    buffer.count
  }

  @inlinable
  subscript(node: _Node) -> Element {
    @inline(__always)
    get {
      buffer[node.offset]
    }
    @inline(__always)
    nonmutating _modify {
      yield &buffer[node.offset]
    }
  }

  @inlinable @inline(__always)
  internal func ptr(to node: _Node) -> UnsafeMutablePointer {
    assert(node.offset < count)
    return buffer.baseAddress! + node.offset
  }

  @inlinable @inline(__always)
  internal func extract(_ node: _Node) -> Element {
    ptr(to: node).move()
  }

  @inlinable @inline(__always)
  internal func initialize(_ node: _Node, to value: __owned Element) {
    ptr(to: node).initialize(to: value)
  }

  @inlinable @inline(__always)
  internal func swapAt(_ i: _Node, _ j: _Node) {
    buffer.swapAt(i.offset, j.offset)
  }

  @inlinable @inline(__always)
  internal func swapAt(_ i: _Node, with value: inout Element) {
    let p = buffer.baseAddress.unsafelyUnwrapped + i.offset
    swap(&p.pointee, &value)
  }


  @inlinable @inline(__always)
  internal func minValue(_ a: _Node, _ b: _Node) -> _Node {
    self[a] < self[b] ? a : b
  }

  @inlinable @inline(__always)
  internal func maxValue(_ a: _Node, _ b: _Node) -> _Node {
    self[a] < self[b] ? b : a
  }
}

extension Heap._UnsafeHandle {
  @inlinable
  internal func bubbleUp(_ node: _Node) {
    guard !node.isRoot else { return }

    let parent = node.parent()

    var node = node
    if (node.isMinLevel && self[node] > self[parent])
        || (!node.isMinLevel && self[node] < self[parent]){
      swapAt(node, parent)
      node = parent
    }

    if node.isMinLevel {
      while let grandparent = node.grandParent(),
            self[node] < self[grandparent] {
        swapAt(node, grandparent)
        node = grandparent
      }
    } else {
      while let grandparent = node.grandParent(),
            self[node] > self[grandparent] {
        swapAt(node, grandparent)
        node = grandparent
      }
    }
  }
}

extension Heap._UnsafeHandle {
  @inlinable
  internal func trickleDownMin(_ node: _Node) {
    assert(node.isMinLevel)
    var node = node
    var value = extract(node)
    _trickleDownMin(node: &node, value: &value)
    initialize(node, to: value)
  }

  @inlinable @inline(__always)
  internal func _trickleDownMin(node: inout _Node, value: inout Element) {
    var gc0 = node.firstGrandchild()
    while gc0.offset &+ 3 < count {
      let gc1 = _Node(offset: gc0.offset &+ 1, level: gc0.level)
      let minA = minValue(gc0, gc1)

      let gc2 = _Node(offset: gc0.offset &+ 2, level: gc0.level)
      let gc3 = _Node(offset: gc0.offset &+ 3, level: gc0.level)
      let minB = minValue(gc2, gc3)

      let min = minValue(minA, minB)
      guard self[min] < value else {
        return
      }

      initialize(node, to: extract(min))
      node = min
      gc0 = node.firstGrandchild()

      let parent = min.parent()
      if self[parent] < value {
        swapAt(parent, with: &value)
      }
    }

    let c0 = node.leftChild()
    if c0.offset >= count {
      return
    }
    let min = _minDescendant(c0: c0, gc0: gc0)
    guard self[min] < value else {
      return
    }

    initialize(node, to: extract(min))
    node = min

    if min < gc0 { return }

    let parent = min.parent()
    if self[parent] < value {
      initialize(node, to: extract(parent))
      node = parent
    }
  }

  @inlinable
  internal func _minDescendant(c0: _Node, gc0: _Node) -> _Node {
    assert(c0.offset < count)
    assert(gc0.offset + 3 >= count)

    if gc0.offset < count {
      if gc0.offset &+ 2 < count {
        let gc1 = _Node(offset: gc0.offset &+ 1, level: gc0.level)
        let gc2 = _Node(offset: gc0.offset &+ 2, level: gc0.level)
        return minValue(minValue(gc0, gc1), gc2)
      }

      let c1 = _Node(offset: c0.offset &+ 1, level: c0.level)
      let m = minValue(c1, gc0)
      if gc0.offset &+ 1 < count {
        let gc1 = _Node(offset: gc0.offset &+ 1, level: gc0.level)
        return minValue(m, gc1)
      }

      return m
    }

    let c1 = _Node(offset: c0.offset &+ 1, level: c0.level)
    if c1.offset < count {
      return minValue(c0, c1)
    }

    return c0
  }

  @inlinable
  internal func trickleDownMax(_ node: _Node) {
    assert(!node.isMinLevel)
    var node = node
    var value = extract(node)

    _trickleDownMax(node: &node, value: &value)
    initialize(node, to: value)
  }

  @inlinable @inline(__always)
  internal func _trickleDownMax(node: inout _Node, value: inout Element) {
    var gc0 = node.firstGrandchild()
    while gc0.offset &+ 3 < count {
      let gc1 = _Node(offset: gc0.offset &+ 1, level: gc0.level)
      let maxA = maxValue(gc0, gc1)

      let gc2 = _Node(offset: gc0.offset &+ 2, level: gc0.level)
      let gc3 = _Node(offset: gc0.offset &+ 3, level: gc0.level)
      let maxB = maxValue(gc2, gc3)

      let max = maxValue(maxA, maxB)
      guard value < self[max] else {
        return
      }

      initialize(node, to: extract(max))
      node = max
      gc0 = node.firstGrandchild()

      let parent = max.parent()
      if value < self[parent] {
        swapAt(parent, with: &value)
      }
    }

    let c0 = node.leftChild()
    if c0.offset >= count {
      return
    }
    let max = _maxDescendant(c0: c0, gc0: gc0)
    guard value < self[max] else {
      return
    }

    initialize(node, to: extract(max))
    node = max

    if max < gc0 { return }

    let parent = max.parent()
    if value < self[parent] {
      initialize(node, to: extract(parent))
      node = parent
    }
  }

  @inlinable
  internal func _maxDescendant(c0: _Node, gc0: _Node) -> _Node {
    assert(c0.offset < count)
    assert(gc0.offset + 3 >= count)

    if gc0.offset < count {
      if gc0.offset &+ 2 < count {
        let gc1 = _Node(offset: gc0.offset &+ 1, level: gc0.level)
        let gc2 = _Node(offset: gc0.offset &+ 2, level: gc0.level)
        return maxValue(maxValue(gc0, gc1), gc2)
      }

      let c1 = _Node(offset: c0.offset &+ 1, level: c0.level)
      let m = maxValue(c1, gc0)
      if gc0.offset &+ 1 < count {
        let gc1 = _Node(offset: gc0.offset &+ 1, level: gc0.level)
        return maxValue(m, gc1)
      }

      return m
    }

    let c1 = _Node(offset: c0.offset &+ 1, level: c0.level)
    if c1.offset < count {
      return maxValue(c0, c1)
    }

    return c0
  }
}

extension Heap._UnsafeHandle {
  @inlinable
  internal func heapify() {

    let limit = count / 2 // The first offset without a left child
    var level = _Node.level(forOffset: limit &- 1)
    while level >= 0 {
      let nodes = _Node.allNodes(onLevel: level, limit: limit)
      _heapify(level, nodes)
      level &-= 1
    }
  }

  @inlinable
  internal func _heapify(_ level: Int, _ nodes: ClosedRange<_Node>?) {
    guard let nodes = nodes else { return }
    if _Node.isMinLevel(level) {
      nodes._forEach { node in
        trickleDownMin(node)
      }
    } else {
      nodes._forEach { node in
        trickleDownMax(node)
      }
    }
  }
}

https://github.com/apple/swift-collections/blob/main/Documentation/Heap.md

Binomial Identify

Rule of Sums

Choose one or another. Add

Rule of Products

Choose one and another. Multiply

General

Finding the midpoint of an array. Avoiding overflow.

ARC or Automatic Reference Counting is system by which objects store a count of strong references that have been created in memory.

Once the number of references reaches 0, the object can be deinitialized. 

A strong reference cycle or reference retain cycle is when two objects store strong references to each other. In this case, neither object can be removed from memory because the reference count will never reach 0.

Imagine a case where this type of object relationship was being created in a loop. The memory used by the app would grow indefinitely. This would be the cause of a memory leak.

It is important to be careful when creating object models that reference other objects. Closures can be particularly tricky because they store references to objects in a way that isn’t obvious to the developer.

A way to have an object relationship where two objects reference each other would be to make one of the references weak or unowned. 

This can be accomplished by marking a property @unowned or @weak in a class, struct, or enum.

In a closure, a capture list is used to mark references as strong, weak, or unowned.

Let L denote the left child.

Let R denote the right child.

Let P denote the parent and position.

To easily remember tree traversal orders, pay attention to the position of P in the following strings.

When P is in the center, it is In Order. When it is first, it is Pre Order. And when it is last, it is Post Order.

L – P – R | In Order

P – L – R | Pre Order

L – R – P | Post Order

Note that L and R are always in the same order. The only element changing order is the parent.

In Order

leftChild -> parent -> rightChild

Integer values come out in order when traversing a Binary Search Tree.

Pre Order

parent -> leftChild -> rightChild

Traverse parent first (pre).

Post Order

leftChild -> rightChild -> parent

Traverse parent last (post).

Code

class BST {
    var value: Int?
    var left: BST?
    var right: BST?
    
    init(value: Int) {
        self.value = value
        left = nil
        right = nil
    }
}

// O(n) time | O(n) space, because we're storing all values in array
// Note: If were were just printing values, space will be O(h), where
// h is the height of the tree.

func inOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    inOrderTraversal(tree: node.left, array: &array)
    array.append(value)
    inOrderTraversal(tree: node.right, array: &array)
    
    return array
}

func preOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    array.append(value)
    preOrderTraversal(tree: node.left, array: &array)
    preOrderTraversal(tree: node.right, array: &array)
    
    return array
}

func postOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    postOrderTraversal(tree: node.left, array: &array)
    postOrderTraversal(tree: node.right, array: &array)
    array.append(value)
    
    return array
}

func selectionSort(array: inout [Int]) -> [Int] {
    for i in 0 ..< array.count - 1 {
        var indexOfSmallestValue = i
        for j in i ..< array.count {
            indexOfSmallestValue = array[j] < array[indexOfSmallestValue] ? j : indexOfSmallestValue
        }
        array.swapAt(i, indexOfSmallestValue)
    }
    return array
}

The bubbling operation takes \(O(n)\) time and this operation is performed \(n\) times. Therefore, Bubble Sort runs in \(O(n^2)\) time.

The swaps are performed in place. If the given array is mutable, the algorithm can be performed in constant space.

func bubbleSort(_ array: inout [Int]) -> [Int] {
    for _ in 0.. array[i+1] {
                array.swapAt(i, i+1)
            }
        }
    }
    return array
}

Here’s a couple of real world optimizations.

Add a counter to avoid checking the part of the list that has already been sorted.

func bubbleSort(_ array: inout [Int]) -> [Int] {
    var counter = 0
    for _ in 0.. array[i+1] {
                array.swapAt(i, i+1)
            }
        }
        counter += 1
    }
    return array
}

Add a bool to return the list if it is already sorted.

func bubbleSort(_ array: inout [Int]) -> [Int] {
    var counter = 0
    var inOrder = false
    while !inOrder {
        inOrder = true
        for i in 0.. array[i+1] {
                array.swapAt(i, i+1)
                inOrder = false
            }
        }
        counter += 1
    }
    return array
}

The sequence is as follows:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55

The sequence follows the pattern of:

I’ve written three algorithms. Each has pros and cons.

First I want to create a simple Error for a case where \(n\) is out of bounds. We will use this with all our algorithms.

enum FibError: Error {
    case OutOfBounds
}

Our first algorithm will use an iterative approach.

func fib(of n: Int) throws -> Int {
    guard n > 0 else { throw FibError.OutOfBounds }
    guard n > 2 else { return 1 }
    var result = 0, nMinusOne = 1, nMinusTwo = 1
    for _ in 3...n {
        result = (nMinusOne + nMinusTwo)
        nMinusTwo = nMinusOne
        nMinusOne = result
    }
    return result
}

Our second algorithm will use a recursive approach. Notice how this algorithm is easier to read, but slightly more difficult to conceive.

func fib(of n: Int) throws -> Int {
    guard n > 0 else { throw FibError.OutOfBounds }
    guard n > 2 else { return 1 }
    return try fib(of: n - 1) + fib(of: n - 2)
}

Our third algorithm is a more optimal version of the recursive algorithm. Because of the nature of the recursive function calls, and more specifically the operation try fib(of: n - 1) + fib(of: n - 2), we use a dictionary to avoid repetitive function calls.

var sequenceValues = [Int: Int]()

func fib(of n: Int) throws -> Int {
    guard n > 0 else { throw FibError.OutOfBounds }
    guard n > 2 else { return 1 }
    var value: Int
    if sequenceValues[n] != nil  {
        value = sequenceValues[n]!
    } else {
        value = try fib(of: n - 1) + fib(of: n - 2)
        sequenceValues[n] = value
    }
    return value
}

I hope this was helpful!