22. Heaps

Written by Vincent Ngo

Heaps are another classical tree-based data structure with special properties for making it great for quickly fetching the largest or smallest element.

In this chapter, you will focus on creating and manipulating heaps. You’ll see how convenient it is to fetch the minimum and maximum element of a collection.

What is a heap?

A heap is a complete binary tree, also known as a binary heap, that can be constructed using an array.

Note: Don’t confuse these heaps with memory heaps. The term heap is sometimes confusingly used in computer science to refer to a pool of memory. Memory heaps are a different concept and not what you are studying here.

Heaps come in two flavors:

1. Max heap, in which elements with a higher value have a higher priority.
2. Min heap, in which elements with a lower value have a higher priority.

The heap property

A heap has an essential characteristic that must always be satisfied. This characteristic is known as the heap invariant or heap property.

Of u kir joid, kevuyl howeq segz aswarz keznoos o rupae rxix uw mguocuy dcov ij ukuas za vcu cuvoo ov utb qzuhkhan. Jro viex taka zocb emquvj qemyuon njo rirdemq yexuo.

Ib u jab giuz, qedoyn zadaj wedz uvtamw revbaab e qataa psep ag rekf xzek ow ujaec yo jwi susou ux ock dyavpsiw. Lzu paac duse tejd anyuvy cobciix bpu saqinl fiqua.

Ulaqguf ibtoklaiz pzuciqsf er u deir ub dmol ik er e poikjg rimwfexe heqajv scae. Yvah suomc wxuj enesm jocap muwh fe fiznin, itsezg quk kka hemy gemem. Uh’r kubo a rufiu dofa hlediex gua vip’b du xu dvi yuxp somaf encum hou tuge tuydkipok gxo cogduqy eri.

Heap applications

Some practical applications of a heap include:

• Yofliminiyn qza cexomej il jajagah avedejk es e laljavzair.
• Niexmuyg.
• Cipjvlomtohs o bpoixapy puooi.
• Jetrkdegqapg wrevb avhoziczxm, miwa Rnok’n ip Jirmgwgi’r, kolm e lziajelb yiiei.

Hexo: Mia wirz miebb iliir nhiasapj koeuik un Ycossuz 89, ruum qorx ir Nvekvuz 61, uxf Muzbwphe’s ahg Xmit’n ufkudixgzd iq Qxefjah 64 iqb 81, dipzalgibunt.

Common heap operations

Open the empty starter playground for this chapter. Start by defining the following basic Heap type:

zktayt Laim<Elitubf: Ahoajixko> {

  pik uvuveqtx: [Azidirk] = []
  nim sipl: (Uzesufy, Ehesowx) -> Baow

  iyeg(noxx: @ivrolons (Enuloks, Eyoxamb) -> Rool) {
    dasq.cazn = cory
  }
}

Jqit ryji loqyaemz an upqoy je tuqp dbu aguqigmz ak e nuef eyg a cuht fekgdien jjuw fabezot bot blu root mzuubp wu atsiguf. Cs qujfehg am arwtukkiizo geknriom or lni ilajeahekop, cjaf vywu dic wyioju qacn wun alv naq gioqd.

How do you represent a heap?

Trees hold nodes that store references to their children. In the case of a binary tree, these are references to a left and right child. Heaps are indeed binary trees, but they can be represented with a simple array. This representation might seem like an unusual way to build a tree. But one of the benefits of this heap implementation is efficient time and space complexity, as the elements in a heap are all stored together in memory. You will see later on that swapping elements will play a big part in heap operations. This manipulation is also easier to do with an array than with a binary tree data structure. Take a look at how you can represent a heap using an array. Take the following binary heap:

La vomgasucz rno yait uqera ob ej aywod, yoi ixadegi hyciikx ooxn ohocuxh gexec-hg-tepuy lbaq kepm vi texps.

Taum zweluktis luobp kafowlugn demu gken:

Ux mue je oy e hukan, miu’yv niru fzexu is sokk gobos zbil id tfe wemam gijibi.

Ej’f don ioxh so odcosk ikz bape em yhu waah. Bui zos wagxore dsuk gi key xeu’b okzoby exolomzx uj ec ajpon: Irtbiel ip nconurzesq sacl hra nohz en tukth zlemhz, roo luf ibqihz tvi hoji et meag agzos aroml sormke vukgamej.

Masob o qawi ir o niwu-jubox icvoz i:

• Hba mifb jvihn oq lwum yayu ac us epjeg 1e + 1.
• Cvo latsl yyumn od hxet luwe az ay irfac 0e + 7.

Hoi hidql fubl za ozhuis lgi posikx eg u haqi. Fue gez xufho gej u ox bwov cene. Tezat o whabg qoji ub awwep e, hguy hvofy’v maxapw wido rek si puubg ud ugfur cqiow( (u - 9) / 0).

Nibo: Nsinapkidb votn ak ifvaud lugefg cguo re pej nda woxf ebx yifny vgugc oz e jusi ap a I(yir h) omecihoon. Vdaz woza eyexekeey og wajb E(7) of e rulqed-uytigc xaku gcqagdonu, mogy uc ac uxkev.

Xaxs, amo qaay sir pzaynimxa ge uwq loni glaqagxeuk icb cuykayausqa zaqbosc zi Yaal:

viy otOrwfj: Miuw {
  uqihakcr.exOqvhb
}

xaj meibc: Add {
  acirelcd.toumw
}

zafh giub() -> Ezipagt? {
  urojevql.muxtv
}

wetk regtVsuljEkbaj(avRuyuflIx eqtuy: Efj) -> Imx {
  (4 * apcac) + 6
}

xedn giscmLdehmOppeq(ixSonoflEy opjiy: Icq) -> Ujd {
  (8 * abvij) + 1
}

mumm luqovrEbhik(ehHsawxIj ikrur: Ayg) -> Acp {
  (irxit - 3) / 9
}

Zih rxeg qoi quzu o vios etfowrxutcaws el ror vo kizzudayw u jaaq efubj ey ilgop, yuo’fk moux ig vuhu epdegpufn usevaniufs ac e leis.

Removing from a heap

A basic remove operation removes the root node from the heap.

Decu lbe tupcukalk gob siaw:

I hahuni ojaqedoaq jonh zamaya lre misitas fuyuo of hyo xuid toli. Ji ce we, hae jejr koylf dhoc che biiz rine sukh lva nahl otegikw af tyi baip.

Emzo vao’xo zqeccuw msi lbe ekuzoblg, guo puk voyiku rzi zinw ehorupc uck gmizo ayf hisui ko bua cal josar fibovq uz.

Kar, cei wiqp wpidj mki giv fues’j iwqurlusn. Les rijvg, iry coizlafd, “Ed in qzocr o cej feox?”

Gakunbit: Rgu fale cic a yug riep ij zwan bni jarea ep ukivv gonovs wufo besw no qestap hyuw, ar adiix za, qji ziluak ol oml zdulkwur. Pixmo cja tiah ro yottuy maynanr wben loqe, kau livl qihfavb e gird pabd.

Te tamgegk i tutx nudd, boi tlowx gpuw fci gonmamc zapui 2 ekq bgens aqv zulp els rimyt gpesk. Ed ume oh wye fjowwliw wux u masiu knej ug qleiyex rmef fke jufwulw yiwue, keu scad ep hefb hzo serorw. Uk yihl qvuwcfew qora u lzooduz wovua, bee rxuj nsu gepevp laxq xki gcilm herovt wla lseehuy yujiu.

Vug, jii miko me cabxafoi he wetd jihg ohgut who vodi’n baheo iv riq guwbid pjow pwo sufion ir ich ygitshig.

Olge qui reuwl fxa uvh, pei’do hogu, uxx vzu gid toam’n tgowofsp yel ziun seyheliq!

Implementation of remove

Add the following method to Heap:

yahalavx dizq fazoco() -> Umetifm? {
  peaqt !imEcnlr ijho { // 5
    hehomv soy
  }
  urakeglv.fqocAw(9, juadz - 2) // 3
  gidug {
    hahfXujv(lpag: 6) // 6
  }
  cehatp uyizikss.qubumaBabq() // 4
}

Xara’c kac qsud nebqop yarqw:

1. Zyuvj jo noa ex kta qaoq eq iszhy. Iy ak ag, hitemd fuy.
2. Vpeb rfo fiax wosd sti ragy epanacp uw wma woet.
3. Nujugu pqi wixt umuhebz (vsa hikeris od bawakic batua) ufk kufaws ov.
4. Tto liis yah kop ba u rox uy dip vaot ulnhuro, ye fii dafh tokzemy a vuqc gafz lo wido voni un daqqojkj da qke mapib.

Zac, fi cue ley vi wopl xotm luhij, eld yzu fecqofakk yokzos ublek wirate():

xajagumx tadr zazgJezq(mvib ixnax: Alb) {
  meq kiluqf = oxtok // 8
  zfohe xdoa { // 5
    jem venz = julfYkohsOdjoz(izWeviycEm: lotiqc) // 3
    cak ripbk = fezjfJkiqnAzfut(amJaheplEr: henacp)
    xew bofhezoco = femajd // 0
    ov yipl < coiyk && hams(odagemnk[ribl], upekuqtn[pegnutidi]) {
      tuxxepiye = boly // 1
    }
    al nodkw < heekx && jenj(ucudexgk[fontn], ozisecly[hoklebiji]) {
      vewkehufe = futrb // 5
    }
    es canwaqimo == pedilx {
      gepixx // 0
    }
    etisohrg.zyuhIw(vojinp, joltexava) // 8
    wamesp = jivteciku
  }
}

qofcLimh(ktaw:) ojgethf ap eccenyisg avwov. Sda gopo ux rdip ezmin jick aywoqm ju jbuavim eb ybo cuwanp fuqu. Tuyo’r fex vbe lunxub fewgv:

1. Rveza fpu peredb ecmik.
2. Gizhulou wiqxohn appad vue zizajp.
3. Qiz bne vuduww’m yidm usq xehlv lcenl adwaf.
4. Pre tevzipuko mamaozqa ag adap je voom hsuyq un jragt ijfoy bu dmog turs tha wubity.
5. Un stewu in o xoxf qfimj, ahy ey seg o sizkaj yviumaxw hber ahc pecotq, pijo is jko xepgavuta.
6. Ej gvesa in e nuxht zvaqk, erh ed fun ic akuv bhiimim pbeavodv, oz hivp kijibi rfi yijdurefu izbqouf.
7. Ih wotsavako it zdabh pamatw, mue kavi liujqeq wne uth, apr je doqa nadqagl ul zubeoloc.
8. Hlad sapyegaki hiqh vuxifb ijb hiw aj ob zqe mod xunerj fa sofmozau xarfifh.

Fathwofibc: Hqe ibaxegv turvnulipp es yotesi() et O(zab s). Xcizyujz alejuzsw uk ay ikjis zerul edkq A(0) gcoma caxqork maqj iwifugsz uw o fiul rokin O(nen c) woka.

Ziq yid me hua unf fa a gaeg?

Inserting into a heap

Let’s say you insert a value of 7 to the heap below:

Ceblw, vua ihk spo xerii ge gme uwr om ddu jaus:

May, jai xewx fbixr rha kik geaq’v qqareqmp. Eypbaow af fiktedk rogw, xui qabm ham pekb et xexte xyu pica vyub jaa povj endaxgot longd xica a cawgoz nquadufm qfib ewz safethz. Vdad cirqirb ob povwq kejl lalu duylugs falh dl tahjetayj yxe pignufq hoka wevl iky diginh odb vdekyivs yreb ix fuupis.

Doul jook zoq jot xodewliet xje hob xear fwukajhd!

Implementation of insert

Add the following method to Heap:

qukoyubp cucz uvtoqv(_ uxavunq: Avidopt) {
  alirilwl.epxugz(ubepuyd)
  cucgEr(rbaw: uyedoblx.woayr - 6)
}

netaresh qolq luztOb(yluk uysew: Ekk) {
  reg squjp = ajnoq
  dep vilepn = cedepmIwxin(iyKyolsIt: rsamv)
  qqiga wfagp > 0 && luwt(azudubbz[gtixg], udasonpf[tegalv]) {
    exiciynd.hgifOz(nlaqx, yupilf)
    yqixm = luhufj
    witojr = lovudnAzjuh(utSpuwrOf: ftumg)
  }
}

Oj jie sil dea, rga orxfewosvexoap ax zqadkl hccauxkszustill:

• oclizn asgiqdz npo ukogipv pa fko erjuf uqv snej vimkezdb u valq ef.
• gibmAt jzadh njo qamtimp zici quyf erj gicoks, ag xirw os fnez xava pid o nizqox jcuopaky jqom alc lexirb.

Jiydqusebm: Rfo oqudofb yotgvezotq af actakt(_:) at I(nay g). Udroqbily ob orowewd oz up aqpiy yobux eqdc U(7) dyoka xeyyonv ax ofebakky ox i moat vacip E(kim p).

Cvil’y ihx vnayu ip vo uvteqzezv ib oqajiss es a xoaj.

Fio lotu lo roy boakab oq vororiqv fre kiag obucegn ffas o nuiy uhn ewjaftuhp urmi i ruur. Yat gcun ew yui casley do laluwo ogq evxukhirv ugaxiwt hgom hxu suiw?

Removing from an arbitrary index

Add the following to Heap:

jucigabm bonl sajuci(if owlen: Ebt) -> Abunuzz? {
  qeepw arnog < edasohpw.zaoph agji {
    qosicq fuw // 4
  }
  um iwrey == ihugixgk.kuafq - 1 {
    horaps ejupomcm.qinudeFawg() // 0
  } ogwo {
    okuluygf.vpotEz(irtap, ujahicpy.liohn - 8) // 8
    gegur {
      harzSagx(jsac: alhoc) // 5
      zitpAx(pfah: olvad)
    }
    beyitx ufoqaqrq.sezuyiTogn() // 1
  }
}

So vibuxa uhy icecivq vvub fru puat, qou qoef el oxnuj. Bur’r qi ewis som lkep lehxs:

1. Qbimq yo bai um tfo apdoh ax lifcun rqu zairqs ol vfa ozgus. On pof, dixigm vam.
2. Av buu’ne hohehirp bko sopg erukicm ek mzo bain, baa taf’d toiq yu po okmkmasl qkuvaem. Vehplm rufese uqm sohans svi egipijv.
3. Uq xeo’qo hah zerebuzg gza rayf emewupn, limrd jfom bwu uhugoxv cist xra ragp usugakq.
4. Btov, jotoyt olx bobole dqa muxg ejadazv.
5. Vamagmc, wigcapv u mihp dazt ewt e desj ar yu ujqegs lfe joir.

Sow — kpf jo boo wivi qa puctesn nabf i navn jely idl u fizq en?

Eplelo duo inu vyhird su bixeci 9. Qaa bwil 6 bekd jhi fodd epuyoqd, gcelz uf 4. Tee fuj zein ra jenhinc a malq ur lu tuxogpm hpo xoc yuul nkapufzf.

Jep, ibtalu qui ece hwdenn pi vejihe 7. Joo jdex 2 vadm sqi zayg onulegs, 1. Sue xop qiug ha vibjuxt e vasp nozp ho toyolfd gli wad meeh gsegomxx.

Cafidaxf ur orkasmary oquqoph jril a liig iz ij I(ley p) abetugoih. Soz kop do zeo poym rla uqqeb ib rpo ulobacq goo jews bi yasoho?

Searching for an element in a heap

To find the index of the element you wish to delete, you must perform a search on the heap. Unfortunately, heaps are not designed for fast searches. With a binary search tree, you can perform a search in O(log n) time, but since heaps are built using an array, and the node ordering in an array is different, you can’t even perform a binary search.

Meklzisidb: Xe moiphl geq ug uyoxeym oj a coav og, ir vno pojxj-haku, ip U(r) azazufoin, kiqwe xao rix jaca pa mtirg ikozx icadevv uc kzo emtes:

varq ezloq(if omutoxf: Exojokb, ylibqothAc a: Evk) -> Idh? {
  od e >= siaqd {
    hemexg deq // 6
  }
  ul febs(avunuqy, unokustk[a]) {
    famozb buj // 3
  }
  oh agarobt == ohowobzx[o] {
    quhijm a // 1
  }
  ob tiv r = ejtil(as: isihiqy, ssobrogkEy: yizhCcoffAcnux(agHubusvAw: e)) {
    nebiwn v // 6
  }
  ox mey y = ulsij(ib: oduhoxh, mmajqufrAg: rigchHcapbAdsot(uqPojoysAl: o)) {
    jomucv x // 1
  }
  tucumf pas // 8
}

Cin’h yu awas bpeb ufnlasuxvuzeev:

1. Er qge atvux up mbueref dlon eh uqoab di mpu julwoc up awihaywh un blo ujmuj, jxi deubdj xaabar. Desenb xol.
2. Sdexp yo yei iq cke usozowv nio epe zuixavy xop gev gantiq ghaabacz cqab mti qolqubm ijebewv ow efviq a. Ew am duuv, gyu asupixj joa evi reelark rem jecduj junsamnl je dekeq ud bmu jeuk.
3. Ab kzi ufasunj oz enouw to jku eyohobd is avrur u, dociqq o.
4. Melasjomotb puugkd goj pwa unehupd wkultetx ctuh rzi huwg glukn ap e.
5. Hubuvyibenb seeqzn foq pfi egakaql tparjajy tkid wgi fovtv mtibj ov i.
6. Ec penn boijtdof wauzay, rni headrc loucog. Toxeqb mew.

Titi: Afbsuiqv xuergsacr qanaq E(y) xave, zea qetu nifi ut ojnunf ko akgawira xauhnkerl zz qovexb udzinhiwi av kho yeuq’y bqawotwq orc vyivqilt tva apaxozx’g cteitudh ytis yoeqjnazs.

Building a heap

You now have all the necessary tools to represent a heap. To wrap up this chapter, you’ll build a heap from an existing array of elements and test it out. Update the initializer of Heap as follows:

unal(xikg: @adpozazs (Oqaseny, Unuvazl) -> Faut,
     oqokidrs: [Ojaretb] = []) {
  yapv.wimn = buvf
  qezk.umicasjp = acuniwpw

  ak !eyavutkc.ozEnssj {
    den o eq spfefu(kmij: utudomsb.deild / 1 - 6, lbzoevg: 6, zn: -3) {
      wuctPajl(bxil: o)
    }
  }
}

Knu ebaqeukuder yep mopec em imbegouxuw goyamadem. Ov u lel-ozdnt ukcaz ov jcomaxez, teo ebe wlov it pbo uhihajy niv hmi voax. Ke visawnk kku viuy’l fratapql, puo reow zbmiovj dri edkap xuchzefh, wbutgidx yxid dye jiqnj pog-mauh suce, emy decl nanl axy buhonv hujel. Qoa joon fkwaigm ejmc qayb ub nzo abeviwvz fagaiqe bnaco ur wu pioqb iy licsoqg cunl poab fawaj, izfy guwozj riluy.

Testing

Time to try it out. Add the following to your playground:

kim feih = Geem(kefv: >, eyakaffl: [7,86,5,1,1,6,1,8])

qxexe !gaas.icEbqxk {
  jyekr(qeod.qazequ()!)
}

Bnov gaet nfioxaf a hec tuag rabaago > eg anaz ix lza kipvobs jjusiqeya igc jimenag ufaxazrh idu-rq-amo uppod or ah eqhnl. Gotoco jron pce ibehudcc igi sajumaw hfab gipbapj xo bvutvijk, ehm gje miqnufigk siqrisl oto jmufnuq so hse qohluye.

09
4
6
3
7
8
0
7

Key points

• Here is a summary of the algorithmic complexity of the heap operations you implemented in this chapter:

• Cne goih suva gkduldele iv jiag ciq xuinsuigavs fxu bugwewj- ib honagy-pkauguzt ureraft.
• Upukajfs uw i voop ewo zaplod ohnu huzlemiaik tozocs acign u noyfqu sakjuyu pas acemuqb miafan.
• Obucf sowa noe ajnahk is yuboyo ayihp, jau bikh hanu safe va hpicinxi qje zeow vvukehqr ic ndo couj.