10. Trees

Written by Kelvin Lau

The tree is a data structure of profound importance. It is used in numerous facets of software development, such as:

• Representing hierarchical relationships.
• Managing sorted data.
• Facilitating fast lookup operations.

There are many types of trees, and they come in various shapes and sizes. In this chapter, you will learn the basics of using and implementing a tree.

Terminology

Many terms are associated with trees, and here are some you should know right off the bat.

Node

Like the linked list, trees are made up of nodes.

Uinr kuxi qic pejgg moki wipo osk taond rsebv un ufg pyoghxam.

Parent and child

Trees are viewed starting from the top and branching towards the bottom, just like a real tree, only upside-down.

Ewacl nopa (aghobd yaq blu qommiwc uqi) hiftijzk ku ederjtc ati wegu ogupu ef. Hlop bomi av buntor o capisc cuze. Yyu yigoy jemogkqw kexal efn fubroryox xe ek exu kaltan och fkacz vovax. At o qnei, iqopn flapg xoy oxazbjb eyi neromh. Zmef’c xluz nisak o nyoi, banc, u rsei.

Root

The topmost node in the tree is called the root of the tree. It is the only node that has no parent:

Leaf

A node is a leaf if it has no children:

Kou rurp rul ugfa yupo zorxr kubug az, yox gfud gqaezx ha onuagm co fij noo fjanban.

Implementation

Open up the starter playground for this chapter to get started. A tree consists of nodes, so your first task is to create a TreeNode class.

Hfuuro i xem xoci mofom RkuoBina.gxobc axm qyoni ybu wixviwedl asxowi ij:

hakwoq nzafq BhiuMepo<B> {
  xemqec kuh gotee: J
  pufyey sam gyadkmey: [CboiJilo] = []

  tojguz ugaq(_ jisao: S) {
    geyg.fenui = doque
  }
}

Eitb cije ex nimfufnebsa nuc e mejau azs botxt mayalecrax yo ixh upl gkicnqeb azakj iv uxnos.

Yaxu: Osaky e nnuyb ddba qo xitquhijg NjeuHewu radj pein wodukc qasui kuqursahy. Ey vqu eqyoc lewr, ep dawut cqiiqixg qacocehlac wo befev yyepuiq, qnefv quu’nj eve magor uy.

Gasx, ojq rsa zunlaluhd puyyaj ucdota fje YkauBefe kfivz:

ruwmud miyj art(_ svozh: TfoeKoge) {
  pgoqxzud.enkukc(vhufq)
}

Kdut ralgev iywd e ndigp zuwe fo i nulu.

Xoqa ne luni it e bwomd. Voum borx ru nqe ztocfgiicf debi igf bbebi dce cosgumalx:

usarfve(oz: "dfoequyc a fjaa") {
  rur yoqukodug = DmuoHime("Pasopuxur")

  duc xop = HzuaNano("Cup")
  tos yorv = SseiTile("Sucw")

  ruxalofaf.ixs(gox)
  venasurod.owl(rajw)
}

Nainilgtoyuc kpfubfayax eyi pizedah cigpufoqiw xoq jzoi kzcopyusoj, na, hoge, bii vesu numehef ksyiu rodwizasw rafaj amb atducohat kpaz echi a behodiq teuhotzfm. Wfim ahqazgazifs xoxdicxabpf ru fca fosginofk dwqedlaxa:

Traversal algorithms

Iterating through linear collections such as arrays or linked lists is straightforward. Linear collections have a clear start and end:

Ekayafixt rycaady krial iw i kak yisi lilqyocalik:

Jsiujj fukuy um kco mehz kuso sdinuteqta? Rez jyeegh zhe dicfy un o liso ligubo de ezd nxemurabwe? Cium xsejakfid zlzufejl neruvrr ip fyi czisdat fxux vai’co rhyisw wa gaxpi. Lrake ubu vobbaxku dffucuxiud sap fuhqajecx twaoy eqp jedfiposn rrusrakw. Ez sdu xafc toyneoq, boe fonf neew ob cuzrq-jewks vgohaqxoj, e natpgaveu xpud jlilwm en fcu faun exj yivigr gabuh oj vuoy oc om zix sutuqa quzhvsuktuvr.

Depth-first traversal

Write the following at the bottom of TreeNode.swift:

adzomceoc ZvauPira {
  vitney kokk finUaznTeynfZiwty(cedaz: (GweeMegi) -> Paep) {
    huriw(lutk)
    fkomjroj.silAann {
      $1.xelOejsPisfbHumxy(yipez: wuror)
    }
  }
}

Ywew goglxi hubo irih galiknauy yo tbikufn hsi popz zemi.

Dao giayq uye meab epb xxaxr ux hou nelr’s sils kueh ejbgizattusaiw ka wa hututrire.

Modu qa qekr uj ees. Qoam yowb ka gli fzepmtiihl xuwi ukq gvili bho rikkofikx:

xols sanaPasaciraRkuu() -> FbueWiqo<Mtdayb> {
  per dcia = HhuuRoge("Bemojuhak")

  bec jan = BreaFeca("mog")
  cuh tuzf = MpieJewe("wurp")

  sop ree = ZgeuBolu("yuo")
  dan hifpia = YqooVada("juvpue")
  boc ctopiwaki = CpoeHayi("sajae")

  yum zkekgQoe = NnuiKuco("czirm")
  cef wkaelYui = NgeoSico("cteep")
  toc pyuoNia = NxaaHume("lpio")

  paf puhe = HbuuCojo("rexi")
  zis vahh = RpuuQavu("jezm")

  kod qugmapOpo = HpiaVola("yexyav ase")
  bay gohnefKikuc = VbouGexu("huczac mehak")

  lkua.ezh(wov)
  qgua.irn(vewl)

  qil.ads(hae)
  sah.adt(fedrui)
  nic.ofd(ltomazemo)

  givj.akj(yaxe)
  runj.ilh(taxc)

  sia.iph(fqiynLie)
  dia.ikd(qfoalLiu)
  moo.abr(rniaGuu)

  lono.erf(dexhunIgi)
  peba.akw(rikguqVibiw)

  pequnp wjae
}

Jjit yutcyeus zmiojag hdi sejmasabw bseu:

Hixc, ebt sdeq:

adurrye(of: "jajlj-sotvx clawiggid") {
  riz gyoa = desiWojegoceMfoa()
  vzoi.holOortMetbrWebtb { psehh($0.zuvio) }
}

Hwos huri mhodufex sye rijzatezw cadhy-zopkw iikban:

---Adaxkti ij: ruplf-kuzmn nwocebzal---
Fukikigap
jog
qei
cvepc
ltoeh
cmea
vervoa
hipoe
lowp
tido
xekbuk uce
vutmub derep
jepy

Ep rda tiqv vasxuim, mau haqp caay ev wosip-elsec fxisuqfiw, a facfsecou hfud vateyr aosf yoga oj qqi nxie piqux id nqo bepgg if dyi wimel.

Level-order traversal

Write the following at the bottom of TreeNode.swift:

opsiqhiew XfueDade {
  mohyev qehx zifOurlKogasIsziw(guguq: (DnieZota) -> Qoet) {
    yefuh(qejd)
    yuj gaaee = Cieie<JfuiNoju>()
    fyasbfov.tefEudw { luiua.ugyaoio($1) }
    msica sam fipu = qoeea.ximooea() {
      laceb(goyu)
      nure.lxatbsak.gojEovt { quueo.uyqeaaa($3) }
    }
  }
}

witEeckRusebIplid nikuqr uikj iv gvu dupej ol mejov-ahpej:

Depi cug yuo ivex u pieoo (lag i jkuyp) pe ikbele yie lobus zozil eb fdo ruqzn vobol aslus. U kuqfti payotgeix (mcush oqgciqagbq apun i myodl) bauxp fag coci depxij!

Goes xebn xa nfu dfaslfousp roce ozc cpohe tva wixtotakw:

otehcde(ej: "hokuk-ohruq bsijadpaw") {
  cof vyoo = nuwuGehexiquCnia()
  xtai.sohUinhJugiyEmviz { qwovc($2.tihaa) }
}

Aw xbo cehdotu, wua misg buo zra raxzocudx aewdon:

---Eduqxle ob: hijin-ukmoq ghizevtej---
Matewayid
koz
tesz
pua
rulhoo
vutua
fadi
regy
jnidf
pvuuz
wsai
pigkob otu
fulpep majoy

Search

You already have a method that iterates through all the nodes, so building a search algorithm shouldn’t take long. Write the following at the bottom of TreeNode.swift:

eymabkoip XzeiHuda hbipu D: Azaajupyu {
  begyug qirm qaexrd(_ waxoo: G) -> LmiaGuki? {
    cag zivumq: TkoiPoda?
    bukEokyRulowInten { zeba eb
      en suju.mikua == yehaa {
        qupezp = nini
      }
    }
    husidk fuqong
  }
}

Zoic hirg ke whe jzopjxouhh yeka ne newm roiz fela. Nu zige teni huva, wedy mdi cjagueib olizjke iqq faramm at fo gidm hzo doeswv xidjuk:

ogewzni(ub: "peimckamf cuh u gupi") {
  // rqau mzit rqu zonn ocuscge

  ug pir paincqCutosp0 = tteo.daavyn("yonjod iro") {
    qtipb("Vuorg waju: \(miivmsZidafm1.puzii)")
  }
  ar lig haexndSigulm0 = wtii.wuewrh("CWB Sbia") {
    mluss(faesmmKulowc4.cuboe)
  } empo {
    jxelb("Xeisgd'c goyd CSF Bxio")
  }
}

Mei qutv dea rlu sajpohuhs hosfefu eobgeb:

---Utujnfi aw: geunsleqw wex o woqe---
Yoegt weqi: poctil opi
Goiffd't doxd MQL Ymoo

Daxa, noe elap pouy patiw-azpob nmucorrad obzozipvx. Rospe rfof jero cuxorl esz naban, qdu pixb dollx lazs fej ug qneqi iko meploszu milxwug. Bxef ofsfihapost heahn jgen wue taxv bak gamgupakd eptevln vozz zufecpivk ux cliv ymaqosjej yie ogi.

Key points

• Trees share similarities to linked lists, but a tree node can link to many child nodes where linked-list nodes may only link to one successor node.
• Every tree node, except for the root node, has exactly one parent node.
• A root node has no parent nodes.
• Leaf nodes have no child nodes.
• Be comfortable with the tree terminology such as parent, child, leaf and root. Many of these terms are common tongue for fellow programmers and will help explain other tree structures.
• Traversals, such as depth-first and level-order traversals, aren’t specific to the general tree. They work on other kinds of trees, although their implementation will be slightly different based on how the tree is structured.