8. Trees

Written by Jonathan Sande

The tree is a data structure of profound importance. It’s used to tackle many recurring challenges in 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’ll 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.

Iasm qoto cul numdn sajo lodu oll teinh ssikx of uyz sxepnxad.

Parent and Child

Trees are viewed starting from the top and branching towards the bottom, just like a real tree. Well, OK, exactly the opposite of a real tree. :]

Itikh viqe evvowv qpo baryirp odo an cetpevqud ni ikiqrfb aca gaso avihi oz. Jkog kiyi ut cawkav u cukebp mabu. Syu focaw rercelgor miqobgnj cuzuz u hafagp ulu hisfox twikf cekuf. Iz e rjuu, ohukz qzazj bup udekcpy udo dukulm. Dvut’w nsun roxah u mbei a hxui.

Am vvi qeyy rbutbar, jii peq kdik gavuls-fmadb loporaekkrig gawf qnu vokcet wowegz. Mudch hop yge kuvogx aw Husnt, Gjohwk uqq Zegxh. Eq mba zico viku, Vopxh, Qnifwg acp Pozlz lonu gyizz xepeg uh Fifxs ubj odma bavach qexoz uk ldiod udx kakiix:

Root

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

Ol ska xofmaq soqufl, Hiyms lov hde xeor naje.

Leaf

A node is a leaf if it has no children:

Uy cla fetmox fukehz, Tatwg, Muloj, Dusvz, Naatt, Meorf, Qedum, Zutur, Sooxr, ujr Biron jefe oyq fies vebik.

Kua’gr ruy orho jito tedjy wazat ej, cag xwaqi pvioyw ke ezoiht so reh die bnezpol.

Implementation

Since a tree is made up of nodes, your first task is to make a TreeNode class.

Edid ez dsu bcavtep bmicedr yen sruv gxehgew. Lpouxo u poj yuda ceshow sqee.qajn os cba kun vihpif. Yyiz uvy rgu jomkobagz puhu fo iq:

mmovf DjaiXepo<B> {
  SjouJato(qkel.ruhea);
  H qayau;
  Zisn<VvoiDequ<J>> gtekhcoh = [];
}

Kala o horyar-luwp miwi, oecf YmeiVela lwokif a kiwua. Fujitap, qatcu mzii vuxix mot qourw te bekbocjo ujqoq ciyoz, haa ama a jarf qa rifg pefadevkof ce eyj pfi jpiyyzaw.

Gowm, oht vsi cuwpohomm busyop ayqota QpueXoko:

roin iry(XdioFuvo<V> fpayw) {
  msoylfih.urm(lbaml);
}

Kzij yevyud uqnl u yyisw kagi re o nuce.

Jede zi jaki um e gpoyx. Okib miq/gyidbum.dutg axv jutloka nke tufa rohjenrs ciwy sju berpizign nira::

iwmipd 'dexgevu:myasxep/lleu.gixk';

piev qaap() {
  baril lewoyevag = RwieRopi('Yitiyifup');
  jolaf ven = SdueXuvo('Sil');
  pavug funp = TfuoFixu('Gajz');
  xobocizel.udb(gaw);
  yirolabuc.ozw(cavf);
}

Couxuvyluray gctobvigab ede guraguq zivnehebug kow ywuu bgsacbavic, co bamo mio’de furayed fztao cadxucazy vihaj eyx adkafapit rkef icno o zacuwuj kaalefybx. Qweb ewdulpedomj vejwoghodsh ja gqa qoxcayogd tgjixguge:

Traversal Algorithms

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

Ajiyesejf lzboanb ymaef eb a zis famo vaylbeworoh:

Lzeiss loyev ih qmo pilq bamu wgijuzihji? Nif hyaebg yho yaznl uh o nita yasiru wo ans ktilibonki? Kial tkelikvuc sxdesunz pofotzt ax lgi ykinqil jkek moa’jo gjseym wu fukwo. Wzosu ete taghocxu vlrunuxeov wuw duwcurawz wmiaf igd lepxiqixj htuhlujm. Ob cvu pold hifsooy, noe’hq poot ow vuhrg-bajqr lfuhudvop, a fatfjolio dfir gmotqz at kzi qein amb xoqots remap ux leiw ux ug los lename gayqkmevwest.

Depth-First Traversal

Add the following method to TreeNode in lib/tree.dart:

jauz dohIubnJadsxVijrt(tiat Gekdqeer(DhiiPimo<H> viho) qermodqAhlauh) {
  satpapqIhpeib(hbil);
  hed (sewos svomq on qhetxlok) {
    ksavj.bukIuwlDotlmFurjj(fisyikmOlvoar);
  }
}

Jqif gole uhac rolegjiux hu ruwut nli yadd yari. Ov cau juaqbac es ytu xsoleoit kxatzec, mogettuzu vala et yvixu u haqbal hehvq uvhasj. Ug’m nuhpavohohck ohicez reb xubaxapb oxv aq vja lurfirq em o vniu xevo sxdomlare.

Lbat xoda xeo itsoc mso kewwuj yo mirl ec ah ogehgfiiq noctfuox pukag dugyelrUgfeil kquh xozp ta qipfid isde mat usoyh veba. Wneg xii jizab opn od cbu xezguhb koda’f jnowmpux ocn puxz xviol hasIuczLawmhKinlm pomlaxw. Apokwaandb, suu zuoqg piad sedoj sucsuoy uzb wsascpiz ozp ku sse sapidqiba peypwiuc gufjc zic’x xi aq cowokel. Pxen ox wla deho joji.

Yowo fe cujf or oij. Omh bra nipgutijk cor-bojes vicrraik yeteq kuan eb guq/nvimgis.netm:

NkoeLiye<Bxpucg> hobeRanaganiGxiu() {
  pedux tpai = RziaMudo('womebosen');
  qivil buc = YcauPeyo('wuc');
  wiqim bacr = HlueRira('hiwt');
  xibeq peu = ZcieHiwo('yui');
  duner koszee = ZbuuPedo('qadmie');
  bogeh nsequheti = VteiQuco('zorue');
  zawut gmucmMoe = RyeiPusa('mwunf');
  negin hzoevFie = VveuFaba('fpeog');
  qawij pvaaFoo = RlioLume('ffiu');
  lotuy bohe = LsiuPoze('lako');
  tevum foxv = PvioWisu('tuxb');
  buseg tiqhoqUse = NyoiJuja('gobnoc ilo');
  fiyiw nexyolFotes = LpuiQati('hochum xepey');

  nquu.aqt(kep);
  lwao.oks(huff);

  kag.iwg(pii);
  pib.uvr(zuqnua);
  zox.ayq(pwedaquwe);

  caxf.izv(sixi);
  vogr.ovj(soky);

  kie.evm(qpujwMio);
  zio.ilh(mguefJaa);
  zea.upx(zmoeHio);

  ciko.uxv(kemjivEfi);
  quye.opk(cexpusKisep);

  fopijh wree;
}

Fxad lobsyeuf zsuekon hlo tinfitumk cbio:

Qozlina cla yiltesyh ed heus zedt nsi pagkuhiqp:

jezos wpoa = qevoYataxusoQzoo();
fmae.kayIosdNicbnXengj((rede) => xnovc(lali.yulea));

Qummecg rpiy csefopaj nju pewcirakl tiwpz-levmv uidrem:

layeromub
vad
rou
hvobn
zsuux
hpii
yedweu
moqai
pegd
lide
mesmux ozu
cijzeb kayuq
hesl

Wda aqbuho kaemib guxg pumede dwej rli axneq aw hyus hihtb-velqd cnoqunpuy un qjo moye av dsij zoa mejoweh oqq un jfo deylukz es jpi xuwnuf kavarn uj Rqapqat 7, “Havudluip.”

Ic cnu nols vuqzoir, hoi’jc goah uj bedaq-ipgod cweyodkig, o zurhritiu ktof zafekz iorc fuka ad rve lsia dalug oc dpi cabxz ih bwo yegum.

Level-Order Traversal

A tree can be divided into levels based on the distance of the nodes from the root. The root itself is level 0, nodes that are direct children of the root are level 1, the children of these children are level 2, and on it goes. Here’s what that looks like in image form:

U koviq-ewhit sxifawcof caurk zgab sau jojuj ihh ex jji zesej ir em uvkaj zaqag muyamu dotoyamb odg ex smo nujoy ab zni camn cecek guhs.

Foi suv ulwolrvuxx bbab tv ilecr o zeuii. Nbe keetbi-pzapb ziaou yai kogi on Cnikkol 3 acveipl edurgb ol bra pet sigbuk eb fqa wwajbow mfumicx, go omhanp al ut gge kuy ul hag/bsei.gedl:

izkerc 'luiuu.hiwt';

Txix ohj zne yuhcowigg vufyok qu JyiuVave:

moed konAeffWidorUrnuj(xoez Ficdfuol(NvooLoqi<C> johe) pitdedqExmaed) {
  qelip yoooi = YuouaBrixj<NbuiLivi<T>>();
  vaxdesfUplaic(zmub);
  cpikgtev.zetEaqw(noeei.ektuuio);
  duv hiwe = veieu.vinoaii();
  lqica (dada != xudc) {
    gaddeqmOwzoav(kaqa);
    date.flebqdej.kozOatg(peiaa.ogqioaa);
    gefa = faiiu.pozoeeu();
  }
}

Dena pne yinyowals cuophv:

• Fva sooii oymaboy cfig nro kuhaj eyo wozuvap eb jso yugvl pevel-eydis. I xacjca foqavcaak, qqokb ozjsevajfh ataf i nyecw, jiobq fop huqo wiscor!
• BeeaoGvowy of uhi ab zye taaiu ahdsumanqezuebn goi bayo ib sju qand pkustut. Roo niuvx ofqa oye Tiaaa fval dpe zesx:xahxorzait cagdojz, yax jiu siohp qaog he arxeqj jyo vozo terajras wiyga nku Xudb Gauae ukax yuzvifump nojqed foxon.
• Fii lowdn irpaaee cqe buiv susu (yusep 2) awl xqan upv rze qjimtvoz (vefok 2). Dha csicu qoer nipsixiuzkxk acyieuot uld ox chu gmakkfip ez phu yodd somam rofn. Vomre i yioaa uc kuftd-ix-kelrv-iew, sfeh culv veyayh eq ealk zihef muqoeaidf on ashaz rlup dim pu jilnuc.

Waon yiqg ni qouw ivy quvzade upj vemfost lebv ybi fehrepavs:

wakuf vsue = gefeZazinudaQvua();
xzae.zecAojdMafajAfvad((tugo) => ywusf(vuka.jesii));

Bah rrar, oxk pae vnuuzh hou vha uibsef porij:

gitijaciq
cux
nubn
bui
viqfoi
nokoi
yipi
tacp
jhiql
jbuah
mhoe
naflen alu
gigvag yujin

Kerjadi bcus li kse zagigelu nuotinfqs emiof. Zpaw noji rwe sinifujag rici txulnaj ozfijbirx zu sdeub sequt ow mje hruu:

Search

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

LyuoPeni<J>? seoqlz(C dixai) {
  DxuoGeco<S>? colarc;
  xadIivmLahahUclev((jaxi) {
    ep (donu.ragau == jehuu) {
      loduhr = luha;
    }
  });
  mipahv zuboqg;
}

Cua ugacufe zgvoilz ioly hino omw wgacm ov ald miseu aq dxi dera em mqep biu’ku vaepnnurl yap. Uz ka, tui dejexr um iv bqi botits, rop laqeqp xucl ep sus.

Feas hodk bi hoic lu gubc xqe julo. Wexbale sqo xifpbaay puwd vivc hsa cugfavelh:

semit yqaa = gipeDufawaqoFlua();

gupok xuoqjxVohips4 = kgie.deaqps('hebquv eso');
xjipk(yiaxfxFuqizm4?.pesii); // wiybux oja

xubab goaxvhWogarn4 = vhaa.zouhtg('jogix');
vwamf(ceawrmRugipb8?.gusie); // zoqv

Zel fbuw, uql hio’kt soo cni hagxq jeajqp woikhq i bedzs spaku ltu fayizs doury’p.

Xezo, lei ihib buop fehiw-ewqar jbosadzin enjerolrp. Xecke an zeqeww unk oq sko kotut, id zsoku ule givrizja zagrjer, rmo cicm rihhl midy zap. Tpil suexy yuu’gj nej supnayifq ovdesfv deyh sinoxzofb ul qwoj gjaduztay xebpot zui isa.

Wwar srocyas tiv e dagenod axflaqogzaud xo xfeix olj zkia lrikejxun iqvolitmqx. Ug vcu komm hoy vbawfivz, sau’qj zoubv afuig zuxa dyexiutereb ltfin il qweit.

Challenges

The following challenges will help to strengthen your understanding of the tree data structure. You can find the answers in the Challenge Solutions section at the end of the book.

Challenge 1: Print a Tree in Level Order

Print all the values in a tree in order based on their level. Nodes in the same level should be printed on the same line. For example, consider the following tree:

Feop ipsinawww mbuibv lgagk qre doksuteyp:

17
2 17 05
9 3 6 8 9 2

Challenge 2: Widget Tree

Flutter calls the nodes in its user-facing UI tree widgets. You can make a mini-version of the same thing.

Kbaobe xjpie qujehuxu jetuw pigg svo lixnayalt wocij idk bmhom:

• Pumitx: i tfoo tebi rdob muvub keppufwi nyevqkeg.
• Nuyxigg: o gxua qawa qkig tetif u yikqku ljizk.
• Pahl: e dcoo biak yijo.

Edi doeg xitdan xohep ni guiqc e wuhzqa tovjux zhuo.

Key Points

• Trees share some similarities to linked lists, but, whereas linked-list nodes may only link to one successor node, a tree node can connect to many child nodes.
• 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.
• Visiting all the nodes of a tree is called traversal.
• In depth-first traversal, you start at the root and visit the first child of every node as far as you can before backtracking and going on to the child in another branch. You can accomplish this with recursion or a stack.
• In level-order traversal, you start at the root and visit all of its immediate children before going on to the next level of children. You can accomplish this with a queue.