A Swift exercise

TreeSearch.swift

func ==(lhs: Node, rhs: Node) -> Bool {
	return lhs === rhs
}

class Node: Equatable {
	var value: String
	var children: [Node] = []

	init(_ value: String) {
		self.value = value
	}

	func outline(indent: Int = 0, visited: [Node] = []) -> String {
		if visited.contains(self) {
			return ""
		}

		let indentString = String(count: 2*indent, repeatedValue: Character(" "))
		var output = indentString + self.value
		for child in self.children {
			let suboutline = child.outline(indent + 1, visited: visited + [self])
			if (suboutline.characters.count > 0) {
				output += "\n\(suboutline)"
			}
		}
		return output
	}

	func add(children: [Node]) -> Node {
		self.children += children
		return self
	}

	func search(value: String, visited: [Node] = []) -> Node? {
		// Have we already visited this node?
		if visited.contains(self) {
			return nil
		}

		// Does self match?
		if (self.value == value) {
			return self
		}

		// Does any descendant node match?
		for child in self.children {
			if let childResult = child.search(value, visited: visited + [self]) {
				return childResult
			}
		}

		// There is no match.
		return nil
	}
}

let a = Node("a")
let b = Node("b")
let c = Node("c")
let d = Node("d")
let e = Node("e")
let f = Node("f")
let g = Node("g")
let h = Node("h")

// Make a tree.
a.add([
	b.add([
		d,
		e,
		f ]),
	c.add([
		g.add([
			h ])]),
	])

// Add a cycle.
d.add([a])

// Test the search() method.
print(a.outline())
for searchValue in ["e", "q"] {
	if let result = a.search(searchValue) {
		print("search for '\(searchValue)' returned node with value '\(result.value)'")
	} else {
		print("search for '\(searchValue)' found no match")
	}
}

Updated outline() and search() to check for cycles.