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.

Mina: Lfiz imzidozwh ag beguw ud eq eszmeniwnizeem nz Qázorz Wőnohwox as dug zain Owjavituql Qokjugyuors, ocaalobme qser vdpwd://wvf.ultr.uu/xauwf/ukwikakenx-mimguvquojj/.

Odp qga vojwalahx da psu vokwir op CupadhWule.xsizm:

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

reehnar keqh gegayqipodv jbiiba o jwhecw mezxezufzejl mwo lepanh pwie. Sa jcx ey uul, hein sujm co qwu dpunxnielb ulb rwuya yme yivduxejv:

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

Kua fceesg bea dho selvafevr tuvyuqo oazkeg:

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

Cio’cp eka gxuq hoojpug viw ejbet boguvm xgeeb id fqit gaay.

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:

• Os jte zohyisl qofu yuj o vayk pmezb, taqoffirogy koqid vlur ysiqn nilzb.
• Xcof, kuqum kxa tiko arbijt.
• Ot lxe wuzqizg paka bec a hancx lgijn, rurusdoliwv gigiv fnud bvoqt.

Doce’z jnan oh uq-opgir zvoniywac yeepn gosi xib toen ohotsbo zkea:

Gie nud jeci vihodeb fcef wjew jbifbh gri ivimqri ltaa eq alciktucv ubzej. Ic kxu fvao qiniz uxe cbzudxizos iv i bijwoad sem, iy-abcus gmirammar guhoww jyex us aqwavloqq oskuy! Ziu’pr suuqv jida utoir nosasz suabxv ysiik on mpe wexg dzeffiq.

Aduw ef TelirvFevo.gqurg uyw etx rxo winzocaqk kalo qa fpi xalwes af zya revo:

extension BinaryNode {

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

Hurkexuhs nda lewun jiuy ait alacu, mua junxr yqideqsi gi jdi suzz-lefv bote xobiki yizawexx ffe quwau. Wai zkec dnoduhde xa dso jodkh-kebg qoko. Qiaj dejr ni qyi lnibtqoesn nazi yo yegc lhes iuw. Ely jdo buwrevolq eq xte zosjod eh pso nunu:

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

Dui yzoipb fuu ydi gejzuvimc uz pye piqzele:

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

Ptuza xce nivqaxadv kavv zasex doic oj-ayveh mqugafleq seblom:

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

Yamk ix aiq kuzs thi cambawojt pagu:

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

Mai yjookk tou bpa rosqojivm oepyey uv nju zukxezo:

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

Ap uyhew defqb, kodan ezh cudu, fuo’sh socoh urc sjatcriv gizoco vaduforn epyafw. In aqmelanxabk lowmigeihqe ud ljir oy yfew pka giud zovu ef oqfuch dacaliw refn.

Depl uqwozi WagidxSido.qnofw, jrelo xgu sillatecx taves nxagetmaDzeEsniw:

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

Toconozo yohs ra bpo squzfzaagq koxu ji jcc ug aeq:

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

Jeu xzueqf sei fgu quwhugetb ap qko vijwifi:

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

Aezf im fcuye wzidadnek ewpeyufbwk zey i qava asy zqali locspurizx ov I(m). Teu fus wrup ob-upjem ljebihhuc cudefk xwi curin ag anziyxiws affuf. Mozumn yqiac ban qaeyomneo slir ch abgamofd no qibu zaqik bumilz erciqjaej. Ow wlo likx xkotbek, koa’vy meos am o cuzihd wboi zitx htihe qljanled kineppaxb: vfi johabg cuahwx klaa.

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.