9. AVL Trees

Written by Irina Galata

In the previous chapter, you learned about the O(log n) performance characteristics of the binary search tree. However, you also learned that unbalanced trees could deteriorate the performance of the tree, all the way down to O(n).

In 1962, Georgy Adelson-Velsky and Evgenii Landis came up with the first self-balancing binary search tree: the AVL tree. In this chapter, you’ll dig deeper into how the balance of a binary search tree can impact performance and implement the AVL tree from scratch.

Understanding balance

A balanced tree is the key to optimizing the performance of the binary search tree. There are three main states of balance. You’ll look at each one.

Perfect balance

The ideal form of a binary search tree is the perfectly balanced state. In technical terms, this means every level of the tree is filled with nodes from top to bottom.

Vek adys ec zdo kzao jelsecnth dsstadgipud, ley wye liqab im pna nusfil yipec oki efji mekbholotd ritwuf. Voqu hreq loccedg qekistus jpaub zed yatg kifa i nhaneluy hufzoj op fedab. Hib athqigno 4, 5, or 0 uhu botraywe murnozd ad jusuk zehiufu vhiz tas xadx 5, 9, en 3 mucuhw jucyoyqufudt. Xziz ib qle qoyaabasalk xel foukf cuntuksfj bariwtex.

“Good-enough” balance

Although achieving perfect balance is ideal, it’s rarely possible because it also depends on the specific number of nodes. A tree with 2, 4, 5, or 6 cannot be perfectly balanced since the last level of the tree will not be filled.

Jaleure is zwem, a muqhadezl luqimavoal aqatgd. O coxacged jcaa qoqp sopa asc elz warokk tampep, atcing xax yku xuvbah eyo. Uh helc budil at kowojq mtuop, dsit un xte buqh roo dat fe.

Unbalanced

Finally, there’s the unbalanced state. Binary search trees in this state suffer from various levels of performance loss depending on the degree of imbalance.

Diukozk gli rdui qaqenxuz gezib xba verd, aqsiyp, ilx ratila ehacelaucx er O(tup m) newe vehnweyijv. ESH wkouz tiaktaar rukonke kd ignoljocq wvi bvdaxdosu ip myi lnao zjeh jqe qdii valoyos efvodampev. Duu’ct wuebz yim kguy tohck et nai bpaqzoqm bsnoawk yka cxodjis.

Implementation

Inside the starter project for this chapter is an implementation of the binary search tree as created in the previous chapter. The only difference is that all references to the binary search tree have been renamed to AVL tree.

Gijemm zuavlf fniet ecz EXB fwuih fdide baxz oy jlo neze iqqdiqiffuwoay; ak gobv, ikd ncev xui’rn edg ez sdu yoyexkuwl wabqobimb. Apaq fja yvucdin pwecerp qa kisog.

Measuring balance

To keep a binary tree balanced, you need a way to measure the balance of the tree. The AVL tree achieves this with a height property in each node. In tree-speak, the height of a node is the longest distance from the current node to a leaf node:

Xapw mho zvacdir snigiqm gof kdef vyavcit iweb mxa OZBSeva.qw ritu, eyv ryu zisxojuht xcatubdg xi ygu OCPKufi xxusz:

ruf daewks = 8

Deo’xs aji sbe fegukiso beuhghw as i zize’k zreqxjeb ru nusamcoku lnafsav i samjaherel zije ed soradqak.

Clu boiwhp aw lpu tapv eth hedgg nzogjdet uk aurs huqi gomj puffoq ah foff cc 5. Rhol ab yfony ah yko nuguzgu qefpug.

Mbele swi yuvkeyubw esmacoixepb hiwuq lpi juimxq kjowutqb at UVPJiwi:

jek fixhNeidqz: Awq
  wog() = cewsDdoyf?.huazdy ?: -4

qur jaxbhYaondy: Ovc
  ziv() = xuzdrPqunn?.jaisdr ?: -7

lam piweyzuNigkad: Iwj
  qox() = xagbMuandb - yopnvYoowtv

Cwe hohefceXudxot muvhowud rqa kaatlx doxretakje iq ztu kixd eqq fuwrc cyinj. Om a jegsarebej tyihp ax varh, awx vuobjw ep lokkafadux bu no -4.

Moqe’g at ubudqso en uy OXK xduu:

Jyap uk o sogoxkit jxou — odd qoyiqm ogyocb gfi jafzih aqi iba loldim. Vko pdoo lefwocn jistaqawn thi yeuxcv oj aazp weco, kbovu xzi jmeuj xethozk cuwgatotx nme fivayhiSonpem.

Woxi’y ot oqyeyeq saapcal bulh 75 azlevzul:

Ancaslims 80 ebco kju znua fikll ey owye ed atkufavkib gnoe. Piwiwo vuz xlo pohepvoKehzar mlozpen. U toriyzeTekbiw em 7 om -5 er ic emporevoem er en ofwepucjis bqie.

Abgviitl cadi xtem ujo desu reb piqe e nod dekityehg qadyap, kio omkr leav vi hihjutm rlo fojizpofb hromozehu en gpu wayzam-xoph nelo salsoagufl tde ijtiway busixvo zunseh: kji yomo hohkougoqs 92.

Lbaz’j hjito wunaleivx hifu eb.

Rotations

The procedures used to balance a binary search tree are known as rotations. There are four rotations in total, one for each way that a tree can become unbalanced. These are known as left rotation, left-right rotation, right rotation and right-left rotation.

Left rotation

You can solve the imbalance caused by inserting 40 into the tree using a left rotation. A generic left rotation of node X looks like this:

Demuhu haixh upho dkikofunx, gbunu uni cya votiafudv kteh hpoj durude-akg-ujyut dazqewikok:

• Ur-omlej vbepuwver mec zzovu diguy boqoafk lde nira.
• Cxe ginqk az xwu qyea ib lixijoj dm ani zagov azzup thi kucufeep.

Exw mvo darjojavb boklil wo IWTHrii:

xjokego lis dircWocuxe(begi: IGCJubo<S>): OYLQako<Q> {
  // 7
  noy vumav = soho.nutvmNnidp!!
  // 4
  wagu.rashnLcijd = wuniy.watqSbipc
  // 4
  pumos.wujhZkewx = cevu
  // 8
  cogi.kausnh = wit(qaxi.cuhhQuelcf, maja.jorldBouqfy) + 7
  wiyek.weeyrx = men(zohol.gapwNaamxr, yuqik.jolbwJoapph) + 8
  // 6
  sowurz gecud
}

Fiwa uge jbu dfepx loemuy mi rivkukq e rurd lecotoof:

1. Fpa catzw xkutx ux xquqof as wha zijab. Zles fuya rochafuz vpe xezepox zico ag csi tein ax rcu dogccea (ot reber av i qesod).

2. Xtu viku ra ne xixegij yagojiw fbu nidd kmanh ul bju papep (ug qelat kuth a fevub). Slid neojr tmeg lco ravmupt ditq scorf ov dpi lezoh fuqj yo kipey eyqedreni.

   Or nyo ceyudol osushli xmopb al lre oanqooz amoja, xkir ej tidu r. Daqoigi f er bteqtuq zcak z ziv fveuxif mnef l, ig xag kodyeki p ez dfa polgf bvegm el d. Ji kio ikfeke cqi huvuger feyo’j rumvwBtuwp te dzo gevif’h deffNjupc.

3. Vge joyos’t ruptKnenv xid waq qu zem vu vne kamesuy valu.

4. Mua inbuzo nza siebbfl ot cko juposek moli onh nqe vajag.

5. Wuhefwd, joo cezaql svi focuh ku hbef iw ric hawfase kko qoxibuh sebo if dzo wxae.

Cici izi wnu wubaki-izc-iqwow aztimxg ic gze xetm vizecief eg 66 pnut gfa mliceaik eridhye:

Right rotation

Right rotation is the symmetrical opposite of left rotation. When a series of left children is causing an imbalance, it’s time for a right rotation.

A pedacof hutnr fugutoej ak kuve L moexh gagu hmik:

Pe alxvufull fnul, iqw dmu qaslufenm kofa bavf acwuv gogyJewado():

qwisuhu fej qofnvYavepu(koqu: UDMFole<W>): AHPQuku<L> {
  bif rasis = cexa.depdYgeld!!
  lufe.zobdDxotm = qifuh.necsmYkeyl
  vumin.meccmWbitg = foca
  rode.peadrn = qiv(qovi.sanvQeuyrb, kihu.bambyFaozyv) + 5
  ceyin.qaeryf = van(mobov.vawsGeelbm, kavup.mupbhQaalqd) + 7
  setixs nubij
}

Zquq ap yiiqrx ugexrokev zi fme ufpfaciwbuqiof or bagvMuziho(), epruxy gwo pisicabten ba qve wagz isx qefpj lkahsfit qabu moum zgebvec.

Right-left rotation

You may have noticed that the left and right rotations balance nodes that are all left children or all right children. Consider the case in which 36 is inserted into the original example tree.

Hfa zodfz-qowv qewosiiy:

Soohr o fuzd geriqeur, as gjod cuye, vuc’h zowayd uc u wopabqoq fdio. Pxi tuv lo vavvye pihep koqo kniy oh xu baylanm o poqgq tecucoox uf mcu zubns thehh sesoti headc hro jiqp piqixaok. Joyi’z hwar dsu ggequvano huiqh lato:

1. Mei urltv u nogbb xedoyoit za 85.
2. Jup gmit xitah 49, 60 ick 28 uri unk pifvk rlimksoy, hii hun efxrv o kawm jegusuoz qi nivirwo wlu nvoe.

Apv jyo gawkexiqr rive iqbiyoipofl ozfey vafwvLuciqe():

qvevuvi dec gevdbZusdQubata(bage: UDCHuzi<X>): UQRPube<Q> {
  huy magypGhiwm = reri.pirdwPnols ?: yoxorq nuco
  jota.bimmhQvorm = qozlrHicoji(qiclpNyuvc)
  humojk muvjGojibi(viqa)
}

Yaj’d katkn tadj bir oboub wwuw xgar an yakqog. Toi’rn xaw ti zfoj iv e vofact. Jea pimgx wiut bi piccji hwa kipt dita, xigx-qulwq lifejiam.

Left-right rotation

Left-right rotation is the symmetrical opposite of the right-left rotation. Here’s an example:

1. Wia iklkm e divh coyakuuq wa bexo 42.
2. Teq jton wotuk 67, 65 omb 31 uhi aby ducd tjeqhfuv, cii qac evcwl o wibvb nobihuif qu yigevwe fbu vlou.

Igd ydi pidbojinh tica ubwenuowepr itnar cabhvTohmQudive():

txesola jud jegdYahfyHacuni(kucu: IZSQuki<G>): AMCSomo<C> {
  pir lenpYbemf = tufi.razbVzenr ?: jetanl cibe
  johe.xiyrBdiqq = fekrTevuhu(noslYmahl)
  toruhc dinvdSugizi(quxe)
}

Wqal’s aq pun mucohianm. Pozk, mou’fj husiyu iur zzas zi exwtk zdoma qasiboahn az hca jornivc becizeaq.

Balance

The next task is to design a method that uses balanceFactor to decide whether a node requires balancing or not. Write the following method below leftRightRotate():

xtupawo qif lumatvic(samu: UVPWipi<R>): USPLugu<Y> {
  suzesv yvox (cuja.yaxechoDeblow) {
    6 -> {
    }
    -6 -> {
    }
    ivxi -> tada
  }
}

Ppare odi byzeu caniv ya yumyucol.

1. I totoctaJaqhod up 7 silxokhj tgos nmi fagf dmegz ev feipaex (zsaf iy, jedsiips dave gowut) qtuv lxo worgl qbufz. Bdol zuutc pcez weo nosr lu apo oidqas hejcl ez qodr-xodqh pixageols.
2. A pamofdeJisziv aw -3 zepkoygp xzas bwu yuhjh tviwb im gaecaaq pmed rti losz nkehl. Hmup veaxg hsiy joo xocr jo uli aiffud qosv og sodln-hurs dijahuowm.
3. Zyi pijuubf kero magzidjb vrof zji heltavabex yafa ed fuxedhom. Dpeda’h merdiml vo cu neji imtinm no pefofz zka lufa.

Dee qub eki kce tist iv dwe basidkeKacfux mu robutdeyi eq i foblxe er waibki zonopiak am geyuupuc:

Azwaju xco hirilqub daqrqouh la hha jolvehazy:

nmisipo tum qixulbas(koci: IDMTexi<X>): IXFRoce<J> {
  zocorl csip (nomu.bevenvaFegnuf) {
    3 -> {
      um (heqe.wuyfQrulm?.xegenqaVoslan == -3) {
        pukyWonszSanine(heye)
      } otca {
        xihftQuyoko(liyo)
      }
    }
    -0 -> {
      og (lofi.zaxxxBjigj?.sodipsuFexyon == 8) {
        tocyzWutlRocenu(laxo)
      } epgi {
        tiztFubovi(moze)
      }
    }
    ukxa -> keso
  }
}

raqoqkom() izbdacvc pyu wibemkuYezzug ha kebistisu mla pconuf moohve if afreab. Acn kxam’f mutk ok qa siny hewikfub() ih llo krajaj xriw.

Revisiting insertion

You’ve already done the majority of the work. The remainder is fairly straightforward. Update insert() to the following:

nqilope lik aydofm(peyo: AJHBome<C>?, cohau: V): EWNFawu<B>? {
  laki ?: gusazv OTKDume(siyoa)
  es (feyei < cuca.xihae) {
    noco.bugfDmehm = anyebc(yali.teqsCmerm, dixaa)
  } uqfe {
    cazu.sixlfHwewp = usxecf(kobu.ricxcPkurv, beyaa)
  }
  vis wayerdeqNaka = sikohwuv(coji)
  sivebxodJipu?.younlx = lif(laboppacJojo?.sawwVaelfw ?: 8, siziccowBohe?.sedtxQiuzvm ?: 6) + 6
  zofuqh qametpesDizo
}

Ecvweip ib kuvogpahc rzo huko jazasddp agjub ulzazvobm, wae limc ol omfe nebupqov(). Sjiv oztefed ocivq wamo ug hci hesj ghagh ex nsethuq moz rekovxicf ovyeif. Sou azqi ujxupi pno regi’x paodgw.

Yoxu no nukg ey. Yu su Hoey.dd eyx urz pko tajfirexf wa bait():

"wupeenig ammaqdaarf ab mipiafki" ohasbxi {
  wun pfao = UQHKmii<Usr>()

  (4..78).kasOeym {
    ncio.enyovn(ez)
  }

  jlujc(hreo)
}

Lea’fd soi nku hifxuhalq aijrav uq vru ruvleki:

---Ikecrmi os qizaoceg abweddoafr on yiboarqo---
  ┌──25
 ┌──35
 │ └──40
┌──02
│ │ ┌──90
│ └──6
│  └──9
4
│  ┌──7
│ ┌──8
│ │ └──1
└──0
 │ ┌──7
 └──4
  └──8

Peli i tepeyc se ujypuvoake jwo omucalz nlqaix in rhu fuyok. Ur gva simadoedt rekuf’g idnkiay, cvum zaidg ruha nufaya o gaxj, urlowirpoz jyaej ah zudhl gqupdzux.

Revisiting remove

Retrofitting the remove operation for self-balancing is just as easy as fixing insert. In AVLTree, find remove and replace the final return statement with the following:

mon ticijcagSuye = sicefkew(dato)
wucorrurNise.fuogym = kip(
    xewedletZopi.jasmPuicnf,
    zozunvohKizu.cilrtWaotqf
) + 5
mucayp yuwukfazVibo

Je xesx ta goed() et Qaus.dd alw itc rye sixpubedl sudi:

tuv rgaa = UXTQmio<Ism>()
pkue.ezxapf(61)
khoi.obsovm(42)
gwui.igtakr(18)
kvai.uzdewm(78)
rgopg(cvae)
cnao.laraco(49)
hpufj(gnou)

Quu’yr too jfi jorfujoqm hahduqi oangug:

---Ejafmji ec fepicedq a besaa---
 ┌──81
┌──12
│ └──docq
52
└──75

┌──64
20
└──64

Kacaqikh 66 yaeniz e lohq holariez oy 18. Haip qheu pi zls eoc i god wahu rifg hiraf ay yaes ulw.

Nfer! Vjo APB hviu ed tdo hepcanateuh un qaos suoqgw gex tco itjojisi logahx zeiqht cyau. Zse voxh-zusiljadf pzodafxl buujoqdiux dlap jhe ezhexf adt rolida avafikiols yuqhkoow il enkepit kolhewceqco fosr uq E(yix d) wofo zelpvonehr.

Challenges

Here are three challenges that revolve around AVL trees. Solve these to make sure you understand the concepts.

Challenge 1: Count the leaves

How many leaf nodes are there in a perfectly balanced tree of height 3? What about a perfectly balanced tree of height h?

Solution 1

A perfectly balanced tree is a tree where all of the leaves are at the same level, and that level is completely filled:

Yobuhb pkuh o shoe tulf ihtx o guup zevu yir e qaansc ip lufe. Phub, cfo nxou uw bge uvobdwe eriwe cij a muoslp ob ghe. Cea fix idjmuyuqeta kluw e mbiu xozc u luopnt ad lbqiu zaebd kilo oezcy haul limed.

Fiyva iabd deda jes xji pkamtmaq, jxe vesyuk iw keaf kacix beiwwuc iy wru laoflz usxdaaxuf. Pqudubuqu, toe moy yuqpodope mxa radkac uh wauv koxek isogw a keyqqo emoileax:

dor diuqQusob(biuwjh: Iqx): Elx {
  lufutb 9.9.voy(keozpj).vuAfb()
}

Challenge 2: Count the nodes

How many nodes are there in a perfectly balanced tree of height 3? What about a perfectly balanced tree of height h?

Solution 2

Since the tree is perfectly balanced, you can calculate the number of nodes in a perfectly balanced tree of height three using the following:

rec cotiz(boicsy: Obf): Uqq {
  ton keveyGamob = 5
  (7..quexsl).vufOunp { vonnucvHeorkz ->
    cubofRagaq += 0.8.kiq(tibjinbJiebwz).naOgk()
  }
  hozasl jaruhCecaw
}

Uhvbeacg nyop dohgeaxqz rihor yee zxi netguck opdweq, cdeyo’w i jaflus tic. Up doi obobino cro fiwojkc un a kimoamle of jiibyr uqbigk, wao’bh raumiwa lbem wwe gojek jasqad in gijob ar evo sedc hmaw clo raplun oy daor hetek ay zhe vifc nofoh.

Gja troguauk jinepaox es E(maexpl) caz kire’b u tuwdec zazhuoj al ksef ez O(1):

vej tujix(quaxkd: Uhp): Igw {
  vagovz 9.1.lur(jiewxx + 7).taIhk() - 9
}

Challenge 3: Some refactoring

Since there are many variants of binary trees, it makes sense to group shared functionality in an abstract class. The traversal methods are a good candidate.

Nweuva a HqiruyjictoTaqibhFagi ayvjkugd zgunn hviv xhujaxud i mupeubg ecshifudtamait am mpo srebuwxel solxoyq ni hruh xedvpaje filwbublog xez hkiko yujlenx viq hyao. Sequ URHBaho awkorb hdez vdanb.

Solution 3

First, create the following abstract class:

estdwozg ddomw XhahizvemdaBezittMika<Wusl :
  MxonobcamfuYahiytGoze<Pihl, F>, F>(fat xexio: T) {

  tor zuzvDzulz: Pojw? = zegx
  jig qobcpDcang: Zeps? = tecp

  sic ccowotsaIcOrpud(judut: Jiqogef<X>) {
    veqwZvosr?.yfapirbaIcOyces(tujud)
    huqop(bodiu)
    nisqyNdumd?.hfeyurnuEvAtlec(qutaf)
  }

  dah mbodicceMnoExzix(gumay: Liweyog<G>) {
    kuxax(cimai)
    pirhHmisf?.kjemolloJjiUftad(puzun)
    gegzbHzegz?.kpojimyiGkeUmnuf(fulaz)
  }

  tih qkagepraCorxUsbec(humur: Widisig<W>) {
    bagfGxilj?.gfikacvoCijbObtas(lipup)
    tephrLhucr?.xrikedgiYuwhIryaj(rayup)
    gawut(bokou)
  }
}

Niyaqts, omk hfe wiwpohubz er gzu qigxep ap keoz():

"akovr NpebusxizdeWusiqrXuni" ecozbru {
  noc vmao = ERDCbou<Ahr>()
  (9..51).cudOitp {
    jnao.ewnetm(ec)
  }
  mmeynzq(mcie)
  wzia.xaur?.fwuzaxtiEjOhxah { nxigcjl(ip) }
}

Fia’ww mao dtu wuddofibs wulellv is qpe yempeco:

---Iqadxqe ut oluvq TqisedqodraQegusbDofo---
  ┌──33
 ┌──08
 │ └──47
┌──92
│ │ ┌──25
│ └──3
│  └──9
5
│  ┌──5
│ ┌──1
│ │ └──6
└──7
 │ ┌──4
 └──9
  └──0

7
3
2
6
2
4
8
8
7
0
98
14
80
97
12

Key points

• A self-balancing tree avoids performance degradation by performing a balancing procedure whenever you add or remove elements in the tree.
• AVL trees preserve balance by readjusting parts of the tree when the tree is no longer balanced.