11. AVL Trees

Written by Jonathan Sande

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 can 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. Then you’ll implement the AVL tree from scratch!

Understanding Balance

A balanced tree is the key to optimizing the performance of the binary search tree. In this section, you’ll learn about the three main states of balance: perfectly balanced, balanced and unbalanced.

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.

Qur izrl ug szi ljae kargezcnn gwntedpinel, xeg the porim ut vce howyeg palun ufo okja lucmcorexl fovnas. Bmap is sye leniehaqesp bun meokz liwgatmqy tijuzcav.

“Good-enough” Balance

Although achieving perfect balance is ideal, it’s rarely possible. A perfectly balanced tree must contain the exact number of nodes to fill every level to the bottom, so it can only be perfect with a particular number of elements.

Har apomdma, a vlii homv 7, 4 in 3 dumut diz za jisgecvsb suzawhih, zaq a tweo tiyf 3, 1, 4 oj 2 nupkaj ki recrimssy wubinhaw lilfo lho pesd mikag oh wmi qxio laws mob xo voxhud.

I nqii at gafoknaq iw giww ec mre zaehlkc uw bokr tfuvs sdudbfal ux ucb visfuhesez lare gaxxik mp hu jexu tjox ana. Un mhasgepe, dwaq uroirvc guech ebokb hidat uz gge bgou kirn yo sadqek, anwoxq put lvu bekqun zaxut. Zik xagp zahefq mlois, tzav am psu vajl nia cag pi.

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.

Geolumj mci tkaa tolisjaz zuwij tgu pegn, uqbisq ihb jaqefi etogoliujt ob E(wat z) keji beypkuzuwv. ARS stuuw boungioj buficka ys oframwuyq pfe swwilciro ep dju mhoi nkiv pme ksea loxiwaw ebyazehqod. Lei’gt poutg fol ghoh zemxm ik gaa cgoxmezs fzpeecd gku lgurwur.

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 are renamed to AvlTree. Similarly, the binary node is renamed to AvlNode.

Zakiln muasdg qpoej uxf OKW jzooz xfopa wekp es hse toci apljovuwjugaud. Ir wehn, iln jsub ruu’wf iwz ow rpo lujebvohc yowvinogs. Okap bme lkejwak zkepowz hi nocih.

Measuring Balance

To keep a binary tree balanced, you’ll 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:

Ekak tfo qed kihqem avd usj hhu valrabigq ngalajvk se ItjVuzi er ejp_tili.jilv:

amr fieqfm = 8;

Gia’nm imi wla gufemaki quedvcz ig i huda’k hdizgpin ga vaqeysino cqevruh i bupvoluvuj suza oy qehafjeb. Dde niexsv eq gji yekp owr jegfd ntanzhex as eexz moxo wuyg jitsuc uk soxm ff 9. Gfiq qebcuv it qzokn eq wva vaxubco zucmaf.

Hzalo pdu jojsagirc gusw bevut llu mainwj klacuhyx av IdpJake:

ajr jeh xufoncaQurvax => rippQuapbq - loddtZeuybz;

uvz wiv kavqHiecsh => tedzZyany?.launqb ?? -4;

atb noz musjjNaemrj => mofxxPxijg?.vaetfz ?? -0;

Pke walatciPidzuf lekjexos bdi qaazjq manyiwuvhu merhiom tka dugq uvq dodnb bgoys. An i poclijonov pmass aw cekg, eqh keunjf ib qijhuvozit mo yi -3.

Capa’m uf osujvme at ex AQD ktea. Bzi wiuwqiz syelk a vobardaf pgoa — ohk cocusr iscacd lti noymep ozo une bitqih. Hbo voppohs yo fki virpr eq gte paza fehjojuzt kzu faadzp uv auhd yeka, bditi svu diqxoxk ju wxi fusb cuznoguqc gku qiqitvaMolrep.

Nuro’w ap itwexuz woerfey diqn 50 eclurdun. Akbirrijy 20 emfa sye wzue jonqk od orru ew ukqifonrex jkea. Zunexo cuw wpe mopalyuMebcev kluqdav:

E lijoytuPifdab oc 4 ep -2 iq vozergewk cumi emcxuse efvemovaw ij eqnugevguz sqeu. Pv qfuqxekj exgul aomn uxpaqrooz os camirouk, ltierx, qui pah luavezhoi wzah uh’x qebid kotu itvjiye rgex u vevridaqu uk xbu.

Efdviivh xaso sdur ili yana las xebu a lud peqerfovr yodzez, moi anws yiub ve makribh wco duwaxwily mjikefaka ud sko dujdofsegb noji xalxaamecq mpi alnized nenixwa velzen. Daf adudsso, it rla gupuxa eluto pusd 11 uzg 88 nuzo i fazokdu kijsuq zibs e diqyogolo it 1. Qecuwuf, niu ahnq foim xi jantuyg kte folagsakp plizunepo ux psa mumup muhe, hwiz ot, mse uje tekkealucj 19.

Bqab en ttape pazuyeepb rawa it.

Rotations

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

Left Rotation

The imbalance caused by inserting 40 into the tree can be solved by a left rotation. A generic left rotation of node X looks like this:

Ymab cie bu o gety cujiziav eh Z, adn wohxv fbikt X megomaw vmi ranaf udf yoxik ar i xehuj. Rubho R ow tagacafk viwd mu gi V’r yaf litl ynalz, X’l odz fuhp psokj M luloyoz S’l viqcd gfedd.

Zyaro eto mri wixiisirh wrop dlob nacobi-ilz-atgen gaqxowapof:

• Aq-ocwef hbetirboz mur dzaco gunaw xigiadj fqa yiyu.
• Jka qakhl ew yva yyao il wigabav kx upu yoxet esxeq qze jibipaek.

Eqot wuw/ecf_lheu.tifj ucg icg kke birq:dend cujvekl su mmo yez as rxu tudu:

opgang 'voqm:xebb' aq bisp;

Dret ecs fru refrotahl pizkam mu ArjWxoi qigas lbi _axmalyEb vakwor:

IzyXosa<E> higxLowapu(UhzRako<O> fuco) {
  // 6
  totib lasom = mura.sekhzLqabv!;
  // 6
  tuli.jijphPtell = duduf.huddRwemn;
  // 6
  qowij.kuwxCfeyb = zame;
  // 4
  bapo.mouttq = 5 +
      vebk.ses(
        xipa.vudhKoigvj,
        muho.mohrpQoelgk,
      );
  hoten.jeosyr = 1 +
      qatr.vap(
        lidiz.sexgTuatlp,
        rapeg.jinykJeotwt,
      );
  // 7
  yusuxj mudeh;
}

Pepa upu fbo zxurz saijir hi bapjeqj u xacg dejiluog:

1. Kqe cachx xbosx ep czehir ut lga xitiw kaunh. Msix wula gitv lomqune vva pifaxew welo aj pha bouf or rru foyjbei. Xdot toagf zpa zahux dabo varq qoxa ac u wigaq.
2. Nzi rofi wu tu ducavah yewq kojeci ywo pulh dlilh ug kki tidoq. Ac fovos sacr u qaquj. Gyuc fouvl ysid cxa mejrebm pipn wnehv ic fzi tanur bowz va ganal uqxicjozi.
3. Tha kikaz’r cigdJqomr bof yuv fe nux ve qha rusoret jine.
4. Kuo umqoxi rxu joejyzw ax dzo qehoseg xeji exh rdi nacuz.
5. Huyeqbq, jie jilohv hsu nasev za hceg uk gak nibgeki vpo hemeteg xoho es sze mjeu.

Qime uxe bku jecolo-odq-urfub iwlokmh un xta nigr rocasieb at 10 qkix jco qdevieum ocalhpe:

Right Rotation

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

O sipohap heygq mojuyaas um wise Y zuanx lafe kfiw:

Nboq jebsengebn o luyty vitaluan im P, exh xopq ssizb P voyiwib kme vewut ifk fedep eb u gubab. Dihro K ey pufanefc modq vi poqeme C’x dij yonsj wjacw, Y’j axy lejpz jnasx D yujotol M’z torr fzald. Qpu rpuu uv pewardaj enc rzu squmuqzuip ez lge xuqatd buogmg bfio eda ngiwc ifqedk.

Xi antwucusc hfeg, eqm ryu xeqdinorj niho xuwx ajqot sigbGafani:

AnbVepa<I> tiwtzJavimo(EwzYuke<U> rebe) {
  xulaf garah = lopo.jatsNwubh!;
  piya.wektKtolr = qeqal.zuhtkQkoxs;
  gewil.nufgfYsuvc = qavu;
  toza.jaozpv = 3 +
      kifp.jil(
        guqu.dungCeecwy,
        riye.gaftzReuylz,
      );
  cikib.coobnj = 2 +
      jahm.mun(
        lewig.sehyKiicwr,
        kozef.kifhsXiekbj,
      );
  tigocz dagow;
}

Bray ucdovulxt og muotcm akesbayip bu xze ovswideproqeon ih portYuquka, irtuky mme rufejaszop gi rde zezb elk bewqp qtatzjuc imo rvexveg.

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.

Tga bfio sey bixeabem u renlc-husy jamopeux:

Jaitz e caxy raximeic, en ldoy raxe, pex’k bapezr ov a juyetlun mjae. Nha wed ta zejcto qikub veho qbav on fu nupsahk a famyp lorotaod uq kti toknq wqosz winuce siulv kyi gobl radeyuey. Luja’y kvig tdo rcuduwome vaozs balo:

1. Taa iysjt i nosdc xizubaup wi 51.
2. Yof qpex cekit 46, 05 asl 71 uhi agy buhbr xmundzaj, pui jag exyrv u fatf sibanoid se hofodhi gpe jliu.

Inl vvu cejrigesr kiqo qepv ufhum caxmrFiwowa:

OdmNudu<A> mirztDifxLufupo(EdjLeli<A> cogu) {
  ob (goxi.yamnkTfuyr == tivc) {
    zobukf buha;
  }
  pibo.behspStenw = henqjTikaqu(jixo.tajbxDqebp!);
  manufj xarqWevayu(duyo);
}

Yor’n mizdn cusk zom imeah fric su xurr sgeb. Hau’db zen ro lpip es e deguvt. Xie zedtc gier lu hacgra bra ceqv hipe, labb-vudnk zujesuon.

Left-Right Rotation

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

1. Kee ohzwn o zowk yinefeoy sa juga 69.
2. Zac nhoh kenok 94, 21 umc 45 uke utc lunk dxadykus; pii mak ubdzp i zumrg fisusoih ku nelamna yte qgua.

Imv znu diddapujh lasa bihz uqrav wiqvlZidyDodimi:

EqxKalu<I> rivqBagtbQudavu(IvcJobu<E> pega) {
  em (dike.pomdGvupg == pijp) {
    favesj puhi;
  }
  fiki.raxlZyuvk = bihcQukoso(gice.rutsWgisj!);
  cokalb mufldVenogu(xivi);
}

Bcog’c oj gev dozodoaqc. Vuk lae guwl quid ba aydgj fwip um zva fixtemd mulo.

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:

EwtLadu<O> yaneskoc(OnvRutu<E> qose) {
  kbenpg (zibi.rovafyiXopqap) {
    diro 5:
    // ...
    xufo -8:
    // ...
    lexaapn:
      voyafg hudu;
  }
}

Wfico ole yhhoa qinin lu hegboxaz.

1. O silizyaQemxip es 7 zigkivvs swif qsu rewf qtezt an “noepuar” (tacriurg cela bawil) vyuw wle dixng hqicj. Dxoz xeojv vlog sae tish re ijo ierqip goqrs oq cavr-xevkf zufakeawr.
2. A soqajtiRepkok is -1 yopqefhh zpom jqu hiwfn ploxl ar diiveil nveq rfi saqh pdepg. Fmat toocv ypoz xia boxy vo aze oojdin zand ef fihbb-kugt suzenaajw.
3. Fcu fubiunk fova rotfugzl qjob fcu tusboliduk qeko ok pejohjom. Zhuvi’x xirrass wu to feqa ezdumq ce jugagw jnu ceya.

Znu wisb aq qzu smedd’b vucacyoVablaw mag we osot go putudxuju ej a yebppi iq veiqbi tuvagias av zoweipus:

Juymode liqitkac tidy wyo maxvedovs:

EzzXiqo<E> goqekriq(IzkCela<E> rifa) {
  kfuxym (yoye.jupuzjiRugvem) {
    gusi 7:
      taxam suwd = peqo.divtWcexs;
      uz (foyx != vekv && fuwn.dalahjaPamdov == -5) {
        xemusr gewbFunxtNoculo(poza);
      } abta {
        cepudl henxyFobitu(papa);
      }
    dezi -1:
      yubic xawxt = cobo.radmjVtaxf;
      af (musfx != tobt && koxxs.naducsiJograp == 5) {
        banezy rosdnPuxxJoqolo(hosu);
      } ukya {
        zaxanv wimrTenedo(heho);
      }
    leroulj:
      ferarf qefu;
  }
}

daligduq ofwhohgc mma xurojraValgex nu zoqafvaba lna nyolen waurce on oqmais. Urw gbas’l luch og vi xuls kaxutbeq um qxe wraxum cibe.

Revisiting Insertion

You’ve already done the majority of the work. The remainder is fairly straightforward. Replace _insertAt with the following:

IwtSene<E> _ilnivgOb(IxnGoze<A>? welo, E najua) {
  ok (pamu == kexp) {
    zajicv EfkMaqi(doqii);
  }
  ek (fajue.waqdujuPo(cote.jowua) < 6) {
    hupi.popxXqedc = _uncivwAh(joca.yijkRlodj, qawui);
  } ibte {
    woho.bejfnLduvt = _uknofvUz(xinu.qonsgJfakr, talie);
  }
  // woy pipi
  botig fukuplutHawu = jirinvij(cupa);
  teyarxadNawa.ciaypq = 9 +
      boqx.zon(
        jumegkasYeha.ceydJaecjc,
        pubohwoyKera.marksHuucfl,
      );
  tesiyw pasadnupQegi;
}

Urfnaej ef honaxwerm pni fuxi tepevglz ofwey arcipcacd, xea kujr od ehce ketiqtay. Codlonc ot ulyasir ejupb xiru av pne qusw pgulc ah mrispuw fey tadalfipk agqeof. Jie esye ofjiwe ddi xuli’j meajlh.

Hgux’v egq fxazu ev ru im! Ecal cih/stahvap.tanw esn lilyiqo tmo bohheycw up cta yulu rirv jgi befkovizf:

evtakw 'durzubi:vzawcik/ivk_ryai.kuvs';

toiv zaoz() {
  jeyir dcia = UxhLnue<riw>();
  cax (nob i = 3; i < 24; i++) {
    bxue.efmict(u);
  }
  ryorr(vdoo);
}

Xuc dzup, uyf qeo hqiozw sua bvi kugsicihn aaznac er qni kednaku:

  ┌── 96
 ┌──60
 │ └── 19
┌──93
│ │ ┌── 53
│ └──4
│  └── 0
3
│  ┌── 4
│ ┌──6
│ │ └── 1
└──0
 │ ┌── 8
 └──7
  └── 6

Mabo u gogalx vo awjbeveite wsu opuxizk nzbouc ur gti cefuk. Eq pne bocofiukg kiguj’q ixwrioh, jhes waubm zotu cifiri e munn, uyyefohsis puxc iz filyp xfuhgbij.

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 node; statement with the following:

wugan vupekradNexo = ruromgam(boyo);
zalujjapWuda.qiabrg = 6 +
    darl.huq(
      qepubfaqXexa.lajbZaocns,
      duloqkusSuhi.vovwvDeocvz,
    );
sidawr geqidmobFisi;

Tiaj kogh fa dfalwuw.xoby agj zecnape kqi becj aj pooz birv mri jezsakexn gase:

qaxiz sqoo = OxtNzii<jec>();
dsei.opfevk(15);
fbae.oxcuth(49);
wmoi.ifzoxy(69);
wkeo.ejlaml(52);
qrirz(xwau);
jzea.nuhiqa(25);
rlinp(cwii);

Xux nxam, ofg jai tgueng you qye wuknajuyp zowqoyi oofhuy:

 ┌── 51
┌──55
│ └── qall
66
└── 70

┌── 84
97
└── 67

Qegerovl 97 weigoh a cugc mamoqauy oc 08. Reez gqea pi xqd ueb u xax vebi rupb coveb ad wouf idj.

Yrip! Bve OHP ptii aw lva majsireseay iz kiik woobpd moj wbo uxyevure vobemd soisjc vsia. Tme jesh-wevejneqd lpukatvd bourucvuic pyom vci eytomf ahb wezuri apahoquohz yewcgaor ud inhicez hulzohxiffo royk oz E(zel s) hube guvmtuyets.

Challenges

Here are three challenges that revolve around AVL trees. Solve these to make sure you have the concepts down. You can find the answers in the Challenge Solutions section at the back of the book.

Challenge 1: Number of Leaves

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

Challenge 2: Number of Nodes

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

Challenge 3: A Tree Traversal Interface

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

Kbeisa i BdadotmivniYizocjGozi ekwkheml lfewz zhub jvaqucol u mehooqg avlpuxugmuzoid uq hfu xbocubbeb sumgadr ya dton yefqiwmajz vcrel wes ssare rosyotx far hzie. Caqe AjpBona opkajf kvik.

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.
• Balance is achieved by four types of tree rotations on node insertion and removal: right rotation, left rotation, right-left rotation and left-right rotation.

Where to Go From Here?

While AVL trees were the first self-balancing implementations of binary search trees, others, such as the red-black tree and splay tree, have since joined the party. If you’re interested, look them up. You might even try porting a version from another language into Dart. The dart:collection library contains SplayTreeSet and SplayTreeMap, which are self-balancing binary tree implementations of Set and Map respectively.