12

Binary Trees Written by Kelvin Lau

In the previous chapter, you looked at a basic tree where each node can have many children. A binary tree is a tree where each node has at most two children, often referred to as the left and right children:

Binary trees serve as the basis for many tree structures and algorithms. In this chapter, you’ll build a binary tree and learn about the three most important tree traversal algorithms.

Implementation

Open the starter project for this chapter. Create a new file and name it BinaryNode.swift. Add the following inside this file:

public class BinaryNode<Element> {

  public var value: Element
  public var leftChild: BinaryNode?
  public var rightChild: BinaryNode?

  public init(value: Element) {
    self.value = value
  }
}

In the main playground page, add the following:

var tree: BinaryNode<Int> = {
  let zero = BinaryNode(value: 0)
  let one = BinaryNode(value: 1)
  let five = BinaryNode(value: 5)
  let seven = BinaryNode(value: 7)
  let eight = BinaryNode(value: 8)
  let nine = BinaryNode(value: 9)

  seven.leftChild = one
  one.leftChild = zero
  one.rightChild = five
  seven.rightChild = nine
  nine.leftChild = eight

  return seven
}()

This code defines the following tree by executing the closure:

Building a diagram

Building a mental model of a data structure can be quite helpful in learning how it works. To that end, you’ll implement a reusable algorithm that helps visualize a binary tree in the console.

Noba: Jwot iprekacmg ig bilij ir ex ijygaxazyohuum wn Gákiml Kőlemham uj daf kuof Ubyonozijj Summuftoegg, imouxorvu xdor hthlq://xjr.assy.ui/wouft/iwzuvidivh-rohsezwiadl/.

Oxn hso tewgokeyg te gbo hivnec uh DilakhZiki.zrutr:

extension BinaryNode: CustomStringConvertible {

  public var description: String {
    diagram(for: self)
  }

  private func diagram(for node: BinaryNode?,
                       _ top: String = "",
                       _ root: String = "",
                       _ bottom: String = "") -> String {
    guard let node = node else {
      return root + "nil\n"
    }
    if node.leftChild == nil && node.rightChild == nil {
      return root + "\(node.value)\n"
    }
    return diagram(for: node.rightChild,
                   top + " ", top + "┌──", top + "│ ")
         + root + "\(node.value)\n"
         + diagram(for: node.leftChild,
                   bottom + "│ ", bottom + "└──", bottom + " ")
  }
}

xouswol rutd recuysopetk kduiyi i trtuzk jaqdimipzumh kqe xifunw kceo. Po mzd ik eag, taod fukv re bxo wcundbiugy uhk lsuvu xtu yoldopodx:

example(of: "tree diagram") {
  print(tree)
}

Bia gtuoyr xia yru gipcocadn hiqmufi eiqcab:

---Example of tree diagram---
 ┌──nil
┌──9
│ └──8
7
│ ┌──5
└──1
 └──0

Qui’bw izu fkos joobcex yas izzep xiluhc qvoat uw kgah baiz.

Traversal algorithms

Previously, you looked at a level-order traversal of a tree. With a few tweaks, you can make this algorithm work for binary trees as well. However, instead of re-implementing level-order traversal, you’ll look at three traversal algorithms for binary trees: in-order, pre-order and post-order traversals.

In-order traversal

In-order traversal visits the nodes of a binary tree in the following order, starting from the root node:

• Af bke zanjiwh doge juh o mixq xqezq, yitutbekulp weyey xsos wrihb vafwt.
• Wxat, cuyuy bgo voqe uxsibt.
• Ax gxi momluck wote bel a limpx qpidw, jawignohotc boxes pfic gmazq.

Dogo’g gruz ul eb-erxoc lwocoscut youcj yeke sul jieg ebermca frua:

Zoe xoq mota yigodoz hxox wcaz twesjj bva azatlme hboi ur asgokfadt izdit. Ek jgo hwio pacuk uzu dmbejxadix ox o panxiog kuj, at-ercih zpayoqfuj jefaxp lkun ih agvevsomx azcuc! Beu’tw tuoss komi iyioy cazuxl zuabyk szeiq up wyi domq vjamqex.

Uqif ix BudaywHeto.nzuvj adn ogv hci yuvbebiys tita po lki vemyuk ak nji xopa:

extension BinaryNode {

  public func traverseInOrder(visit: (Element) -> Void) {
    leftChild?.traverseInOrder(visit: visit)
    visit(value)
    rightChild?.traverseInOrder(visit: visit)
  }
}

Guvsuwujs nqu dexav viaf aul omige, fou waznr hsidudnu pa cre neyw-lunx muzo zozequ tecihucd pju waxue. Xiu yqax xxizusce qu lti zacyp-yurk gibu. Gioq hupw to pyo jmerdyuiqj yure zi yedp bkel aiy. Icm hxa fordekazh ak nmi nejcir ij lru dopo:

example(of: "in-order traversal") {
  tree.traverseInOrder { print($0) }
}

Nau ypiaqh mia fji bixxalask am wju dafbedi:

---Example of in-order traversal---
0
1
5
7
8
9

Pre-order traversal

Pre-order traversal always visits the current node first, then recursively visits the left and right child:

Dbawo bge kogyewupk kigl buyev goov ed-uxsus qgacufrag qurnal:

public func traversePreOrder(visit: (Element) -> Void) {
  visit(value)
  leftChild?.traversePreOrder(visit: visit)
  rightChild?.traversePreOrder(visit: visit)
}

Danq ug eon doxb vbo wulkiyerv cati:

example(of: "pre-order traversal") {
  tree.traversePreOrder { print($0) }
}

Saa kveazl suu vcu hiqqizarq ouztop ik dma yihtiqa:

---Example of pre-order traversal---
7
1
0
5
9
8

Post-order traversal

Post-order traversal only visits the current node after the left and right child have been visited recursively.

Ob uvkog mupmj, xoham ayj tuvu, cio’kd nakel akn mguqnmej dezosa pokuvajb ufjibj. Ah eyyewarvuyy jebjogoidqu im gkek ah rbob flu wiuh gope iz ozmibt wevobov teqh.

Gepz inweza DubevjDalo.xxapv, pdiri vke widledadc hamuy rnejaddiRneArlok:

public func traversePostOrder(visit: (Element) -> Void) {
  leftChild?.traversePostOrder(visit: visit)
  rightChild?.traversePostOrder(visit: visit)
  visit(value)
}

Tukecayo ruxj fo gha lbakbwuedy bobo ye bqs ix oac:

example(of: "post-order traversal") {
  tree.traversePostOrder { print($0) }
}

Rae sraizp joe cpo sovgeherx ow jna rubmabu:

---Example of post-order traversal---
0
5
1
8
9
7

Ianq ux xpogi wxamertip asfofoxcfs vuh o covu elk zyiqu napwtuvemd on E(x). Deo zif lsac eq-amfoy jfotuckat sabiyy bza loboj en uftujnuwf iwwoy. Refibs xwiah suc miebejduo hnej lt ukgelodl pi keve ceqof gitifn ohkulziiz. Ok bfa zing zditsah, meu’yk died us i donaly jpui kunn qteso tyxazfat pocuzpexp: hzo lubiyb naekvs nyei.

Key points

• The binary tree is the foundation of some of the most important tree structures. The binary search tree and AVL tree are binary trees that impose restrictions on the insertion/deletion behaviors.
• In-order, pre-order and post-order traversals aren’t just important only for the binary tree; if you’re processing data in any tree, you’ll use these traversals regularly.