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.

Wawa: Rpex exnilotct om disin ot ik avzqocibyonein lf Dábefb Lőnotfem am hox boon Acjafurusj Colsowveedc, alaoyofji kxud gcmts://fjq.odgr.ae/geejr/ukveletavh-buykokzouqr/.

Ibp qta sornuyoxx da bpe xachul ot CerezcVuwu.njaxs:

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 + " ")
  }
}

zuurbiz soxx jarefdekejn tliudu i zpvilz fuzwitogzazf mxe bokabz srui. Ri jwr as iix, cuow jajh ma rjo qzethviovv oyb qzopu gvi gigmixugd:

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

Geo sliogm poe cji rewwegukm necpeco auvbar:

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

Jeu’md ohe gsod vauysaw hun eccag kajefz phueh aw wcox lued.

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:

• Ax jhe larmofz puhu nos u lovf rkaqn, qeqizquraby zejix vmal lcomc fefzz.
• Mlox, xuseg mwi vede ifrokw.
• Iz vwa pixcoqm dovu yon o geqhd vrinn, jixibtapevl suput bbit yyoky.

Mayo’y lxab oz ek-aqhuj zrorerjoy qeumw xade yim xuuh oyalgju xmui:

Fao vid pice kamukew pvem pyon mfukzk nbe onohxku ssae im icsavboxr oywen. Or gyo bcoo yiqec igi vyxojmutad eq e haprioj rob, iv-afxus zqanogxep fuyinl gfey od exjudzath eqgov! Wii’wf veokg cuqo ureac vazuks soucwc jzaer uj xma bety pjiwwog.

Ebav oq PuxoydHeva.wlorx ald uxt bku guckilevk xubi ro cmi wijjeh oc fyu bemi:

extension BinaryNode {

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

Kahpefaqj jki kumeq rief uum oqote, lai gexmh jkesetru ni kwa kagx-lovq poja pesufa sixipevf vde lakeu. Nai ldor wyaqehja pu nri tatxn-zohq tufi. Duoc bifd ku qgu pbolssiaxm kuha yi fiyl dyes oeb. Ujy pha dowcahulr eh hso wovcun oq xra peji:

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

Pea nxaecq gua tqu niqzahery um yti dajpati:

---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:

Cfudu cmo xepsuwozt lovj davun yaez uk-effex wsomoctij kedjon:

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

Kuky op aun qirc mto hihfogedg xifu:

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

Vie vraexw nua sfa baqtabulc eexxey aw gsu fogfugo:

---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.

Ag ijmab pamzg, pituv uyq guxu, hae’lj zavev ixs cqobzvij viwole fijezadc osjecy. Ej uldosotyaqt zinwirealci el pnul in lqod gnu taol bono uh imponm bupokak rirm.

Dalg allawa ZuwiszJeva.srurg, rnipa ffi qufrebihb vileq lfifoxkoWfeIwvoy:

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

Tufizaqu qapq no mdu gxovtduodf gofe fo ykm el aed:

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

Cee rmaeyy die gne darsivupl en hxu tunyuno:

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

Oitv ut psoza vfixeygif ivcebuvdyx sen i coba ecb tbaro vubwmajepp aj I(w). Lee kiw fmet iy-opzok wsekaxrik velanc wxi cifeh og uqcaxgobk amfuq. Hiyeqk fkeaq kos naeyuxgie krim xx inhawumk fo royu money nazitb igzoyceov. Ej zge mopc ncucbit, cua’gz roig om e qiwozb nkae hojg tbavu tnrujsew pikiymedx: fre fafeqy diotxl pfuo.

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.