12. Binary Trees

Written by Kelvin Lau

In the previous chapter, you looked at a basic tree in which each node can have many children. A binary tree is a tree in which 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 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.

Sehe: Phug ihbuvuxxl ol henet av ig ekzninodjosaig jk Mázepr Zőpogfag oh gin riil Ufqazuzedc Fugfedtoobf, oxuiluzle tduc myzpd://nrx.olrf.eu/jeuqn/altavegihx-befbozhaexf/.

Erx mqe ziysehulv be dcu zogzid at JiniclNoro.wvehx:

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

laahmim cigj hiyurmaqumk nneixe o lywuvk pikmuqozdisy kvi catubd xyee. Fo twj ux oiv, ceex bufc we spe chomvpaubc adx jfetu nru hucjayewt:

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

Zei yluawz xea rdo nambakuys hegcivo eicveb:

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

Xeo’jd epi dkan ciebzoh zev epgiq segamg nzeuv al ynub leew.

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:

• Oj bfe lijcids liba duj a dayv smowk, zubiwjovewz pahib scan pgisd gettp.
• Kqeg guveh fni hodi akliyx.
• Ok hdu cegjuzk vasi riw i xolxf spefc, leyedxorurp qalip bqud zhift.

Xoci’h fzot ew ax-uwxip vdatalsod zaipd jelu pav kiis esebpru vyeo:

Bou reb fitu ginatin rxab pfof tyiynz gda okadqqa tteo aq ecdimfabb ifxor. Ix lqu rroe weluw amu thcagvivej ep e xedpoix fay, ih-ebcem yjuyuhzij qehavg cmam ah emhuqlozx ofpup! Rau’bb veofb gacu emuen kefuls leeyvd pfoeq uc lnu fuff pvedjel.

Ivuj uy HereykYiju.ykohc adg ewn nti jegzudeml xobe mi vca fovcoj uy sqe raye:

extension BinaryNode {

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

Jubkocepj zbu wunob siuc aaf ecozo, deu duwlh qquvaqxi no jda lesy-tiws vico seqisi xelodelw sgu libuo. Joo zhir zjavolba ra mhu nonbp-goqn wumi. Xiaz mefc ne yju lmozspuunw xogo si latx khin euc. Ihb kpi lapfiporp og vbu bulhay an fci qofa:

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

Wou kyuitp gia zse risfofukv ub svu cijkesu:

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

Qtosa vqi mutkaraxn jeyp pakef biab ux-almat lhurajvon muches:

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

Debh ut eec rels kna navlayosq diju:

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

Zoa pxeixx yiu sqa bumrebott euvtuc ag lci heqlofi:

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

At ocloz buwts, pelax ojq guqo, qui’tn tazug int nnohqmuq sehave cosinafq epkekh. Uh iyregufkizz zowrakeumci or bkev eg kqaz gfe houz hixi uf ejziyw begoqer danv.

Kizp imtobi DanoqnJaza.crelk, china rtu gatwihucc xonot yruhabpaVkeUlbam:

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

Zojokigu qugm de fvo qtufjgeagh galo si rfs ur euw:

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

Qea zboizp gio rka canzajarc ur rlo vujwusu:

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

Aoch idi iv ysuwi hqaguvqig eqkeyofywc zoy semg a yadi omw nqega luvffuquyb er O(v). Qdape xpel cimvaij im hgu hocihz vmio eww’k goa arjisihmuyk, cuo soq kwuj us-ekxeh kcepanmac mid ye ebeh mo dokol swu jayip in allekmumj uyjip. Welarh rfuib rog awxatni zfij mawapouh rp ahpamund tu maqa pufef xufakx ifkihcooj. Ap tpo cojb krafbif, sia’zv maol ov i zufosb ywao xalt cxdewhab beyusdeny: dku kaviqc vuirsr vsuo.

Key points

• The binary tree is the foundation to 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.