3 Dynamisch (recursieve) datastructuren

Transcriptie

1 3 Dynamisch (recursieve) datastructuren Bij de ontwikkeling van programma s die grote hoeveelheden gegevens in het computergeheugen moeten opslaan, wordt heel vaak de mogelijkheid van dynamische variabelen (dus: waarbij met pointers verwezen wordt naar gegevens op de heap) uitgebreid wordt tot het wijzen naar gegevensrecords, waarin een of meer pointervelden zijn opgenomen, die op hun beurt weer (recursief) kunnen verwijzen naar andere gegevensrecords op de heap. Voorbeelden van veelgebruikte dynamische, recursieve datastructuren zijn: lineaire ( gelinkte ) lijsten binaire (zoek-) bomen dubbelgelinkte lijsten. We zullen hierna voorbeelden van deze datastructuren verder uitwerken. Bij al deze typen bestaat er een definitie van een gegevensrecordtype, waarbij in dat record een of meer pointervelden voorkomen; pointervelden van een zodanig type dat die pointers weer ( recursief ) kunnen doorverwijzen naar een of meer volgende records van hetzelfde type. TYPE DATAWIJZER = ^DATARECORD ; DATARECORD = RECORD Gegeven : GEGEVENSTYPE ; Wijzer : DATAWIJZER ; {evt. Wijzer2, etc.: DATAWIJZER } Uiteraard zal zo n zich recursief voortzettende streng van records ooit ergens moeten zijn begonnen en ooit ergens moeten eindigen. Dat laatste gebeurt door het pointerveld (of bij bomen: de pointervelden) van het laatste record een NIL-waarde te geven. Die situatie met een pointer als wortel (in het begin) naar een record, dat ook weer een of meerdere pointervelden heeft, is hiernaast schematisch weergegeven. Indien het record slechts één pointerveld heeft, kunnen we er een lineaire lijst mee gaan vormen. Twéé pointers naar volgende records zijn nodig voor (binaire) bomen en een pointer naar een volgend plus een pointer naar een vorig record worden gebruikt voor een dubbel gelinkte lijst. Wortel pointer naar volgend of vorig record pointer naar volgend Figuur 1 Schematische weergave recursief dynamisch datatype 3.1 Lineaire lijsten Lineair gelinkte lijsten kunnen in meerdere smaken voorkomen. Belangrijke smaken zijn enerzijds: wèl of nìet gesorteerd en anderzijds: toegang via alléén de wortel van de lijst of (ook) op andere manieren. Wortel NIL Figuur 2 Schematische weergave van een lineaire, via pointers gelinkte lijst We geven hierna in een voorbeeld allereerst type-definities en daarna een recursief geformuleerde procedure voor het tonen van de waarden in zo n lineaire lijst. TYPE ELEMENT = STRING [ 10 ] ; { of INTEGER e.d } LIJSTWIJZER = ^LIJSTRECORD ; 19

2 LIJSTRECORD = RECORD waarde : ELEMENT ; vervolg : LIJSTWIJZER PROCEDURE Toon_Lijst ( wijzer : LIJSTWIJZER ) ; IF wijzer = NIL THEN write ( ' --> NIL' ) write ( ' --> ', wijzer^.waarde ) ; Toon_Lijst ( wijzer^.vervolg ) {het recursieve aspect} {'RECURSIEVE versie'} Let erop, dat bij aanroepen van deze procedure een pointer naar (het begin van) een lijst als parameter moet worden meegegeven. Let erop, dat zo n recu rsief geformuleerde procedure ons erg gemakkelijk een oplossingsalgoritme voor het toon waarden van zo n lineaire lijst laat aangeven. Indien we te maken hebben met een lineaire lijst van veel records, dan zal zo n recursieve procedure snel stack overflow geven; in dat geval zullen we onze recursieve aanpak moeten vervangen door een iteratieve (dus: met een herhaling... zolang de pointer niet NIL is...). Een iteratieve versie van deze procedure zou de volgende kunnen zijn: PROCEDURE Toon_Lijst ( wijzer : LIJSTWIJZER ); WHILE NOT ( wijzer = NIL ) DO write ( ' --> ', wijzer^.waarde ) ; wijzer := wijzer^.vervolg writeln ( ' --> NIL' ) { ITERATIEVE versie'} Ga de werking van beide versies van deze Toon_Lijst-procedure na. Het is vrij eenvoudig om een functie te schrijven, die het aantal elementen in een lineaire lijst kan bepalen. We geven hier een recursieve uitwerking van zo n functie: FUNCTION Lijst_Lengte ( wijzer: LIJSTWIJZER ): INTEGER ; {RECURSIEVE versie} IF wijzer = NIL THEN Lijst_Lengte := 0 Lijst_Lengte := 1 + Lijst_Lengte ( wijzer^.vervolg ) Zet deze versie desgewenst zélf om in een iteratieve versie. Gecompliceerder wordt het toevoegen van waarden aan zo n (al dan niet gesorteerde) lineaire lijst en het verwijderen van records uit de lijst. In beide gevallen krijgen we te maken met pointer-algoritmiek (die vaak aanleiding tot fouten is). We gaan daar in de volgende paragrafen op in Toevoegen van een record aan een lineaire lijst Wortel NIL in te voegen datarecord : Figuur 3 Invoegen van record door verandering van pointerwaarden 20

3 Om het nieuwe record te kunnen invoegen, zal er altijd een (al dan niet: hulp )pointer naar toe moeten wijzen. De belangrijkste vraag bij het toevoegen van records aan een lineaire lijst is die van hoe, op welke plek in de lijst, moet het betreffende record toe/tussen-gevoegd worden?. Veel voorkomende mogelijkheden daarbij zijn: vooraan in de lijst toevoegen en bij weghalen weer dat element als eerste weghalen (LiFo: Last in First out) achteraan aan de lijst toevoegen en bij weghalen het eerste element weghalen (FiFo: First in First out) gesorteerd toevoegen volgens ordening van een datadeel-waarde We geven eerst een mogelijke procedure voor het steeds vooraan in de lijst plaatsen van een nieuw datarecord: PROCEDURE Voeg_voor_aan_lijst_toe (VAR lijstkopwijzer : LIJSTWIJZER; toe_te_voegen_waarde : ELEMENT ); VAR hulprecordwijzer : LIJSTWIJZER; new ( hulprecordwijzer ) ; hulprecordwijzer^.waarde := toe_te_voegen_waarde ; hulprecordwijzer^.vervolg := lijstkopwijzer ; { er tussen in wrotten } lijstkopwijzer := hulprecordwijzer Ga de werking van deze procedure na. We geven hierna een aantal onderdelen van een eenvoudig programma (met de toevoeg- procedure recursief geformuleerd) voor het toevoegen van lijst-elementen aan een gesorteerde lineaire lijst. PROCEDURE Voeg_toe_na ( VAR vervolgwijzer : LIJSTWIJZER ; toe_te_voegen_waarde : ELEMENT ) ; VAR hulprecordwijzer : LIJSTWIJZER; new ( hulprecordwijzer ); hulprecordwijzer^.waarde := toe_te_voegen_waarde ; hulprecordwijzer^.vervolg := vervolgwijzer ; vervolgwijzer := hulprecordwijzer 1 ) PROCEDURE Voeg_toe_aan_gesorteerde_lijst ( VAR wijzer: LIJSTWIJZER ; toe_te_voegen_waarde : ELEMENT ); { 'RECURSIEVE versie' } IF wijzer = NIL THEN Voeg_toe_na ( wijzer, toe_te_voegen_waarde ) IF toe_te_voegen_waarde < wijzer^.waarde THEN Voeg_toe_na ( wijzer, toe_te_voegen_waarde ) Voeg_toe_aan_gesorteerde_lijst( wijzer^.vervolg, toe_te_voegen_waarde) {hoofdprogramma} LijstKop := NIL ; Toon_Lijst ( LijstKop ); GotoXY(1,24); write ( 'Toe te voegen waarde (0 voor ''einde-invoer'') : ' ); readln ( toe_te_voegen_waarde ); WHILE toe_te_voegen_waarde <>'0' DO Voeg_toe_aan_gesorteerde_lijst ( LijstKop, toe_te_voegen_waarde); GotoXY(1,1); Toon_Lijst ( LijstKop ); GotoXY(1,24); write ('Toe te voegen waarde (0 voor ''einde-invoer'') : '); GotoXY(48,24); readln ( toe_te_voegen_waarde ). Indien je (b.v. vanwege dreigende stack overflow problemen) een iteratieve versie van een procedure Voeg toe aan gesorteerde lijst wilt maken, dan zul je met twéé hulppointers (die in de lijst onmiddelijk achter elkaar 1 Let op het taalgebruik ; interpreteer eerst de code van de procedure Voeg_toe_aan_gesorteerde_lijst en pas daarna die van de aangeroepen Voeg_toe_na. Interpreteer de naam Voeg_toe_na nu als: vanuit een bepaald lijstrecord wordt deze procedure aangeroepen met als parameter de vervolgwijzer. Als vervolgens besloten wordt het nieuwe record in te voegen, dan gebeurt dat dus nà het record vanwaaruit werd opgeroepen. 21

4 aanlopen ) door de lineaire lijst moet lopen; eentje ( huidige ) waarmee st eeds afgetast wordt of je met die pointer soms al te ver dóór geschoten bent of bij de NIL-pointer op het einde van de lijst bent terechtgekomen en een andere hulppointer ( vorige ) waarmee je steeds de positie (lees: de pointerwaarde) van het vorige lijstrecord onthoudt. Schematische aanpak voor zo n iteratieve variant: Wortel Vorige NIL 2 Huidige 3 in te voegen record 4 8 NIL <=Startsituatie NIL In dit voorbeeld gebruiken we records, die slechts bestaan uit een getalveld + een vervolgpointer. Stel nu dat we het getoonde in te voegen record aan de lijst willen toevoegen. We starten door de hulppointer Huidige eerst te laten wijzen naar het eerste lijstrecord (beter: we geven hem dezelfde [adres] waarde als de Wortel -pointer). Wortel Vorige Huidige in te voegen record NIL Vervolgens geven we in een iteratie de pointer Vorige de waarde van Huidige en schuiven die laatste steeds een plek op naar het adres waar eerder Huidige^.Vervolg naar toe wees. Wortel Vorige Huidige in te voegen record NIL Als we op deze manier op een gegeven moment aangekomen zijn op de juiste plek van invoegen, dan moeten we de waarden van de pointers Vorige^.Vervolg en In_te_voegen_record^.Vervolg zodanig aanpassen, dat het lineaire-lijst-aspect gehandhaaft blijft. Wortel Vorige Huidige 4 ingevoegd record <=Eindsituatie Hou ondertussen wel goed de lijststaart in de gaten! Ga zelf voor de geschetste eindsituatie de volgorde van de vervolg-pointers in de lineaire lijst na. Een uit te werken sjabloon voor zo n iteratieve aanpak is dan: maak via New ( Nieuw_Record_pointer ) dynamisch record; vul met toe te voegen waarde; zet pointer naar vorige record op NIL; zet boolean variabele gevonden op False ; initieer pointer huidige met de lijstkop; { ga nu op zoek naar de plaats waar het nieuwe record tussengeplaatst moet worden: } WHILE ( huidige <> NIL ) AND NOT gevonden DO IF toe_te_voegen_waarde > huidige^.waarde THEN vorige := huidige ; huidige := huidige^.vervolg gevonden := True ; { plaats nu het toe te voegen record er tussen / op zijn plaats } Nieuw_Record_pointer^.vervolg := huidige ; IF vorige = NIL THEN LijstKop := Nieuw_Record_pointer vorige^.vervolg := Nieuw_Record_pointer 22

5 3.1.2 Verwijderen van een record uit een lineaire lijst Wortel NIL Figuur 4 Verwijderen van een record uit een lineaire lijst door pointer-algoritmiek Ook bij verwijderen is de vraag weer: hoe en waar?. We geven hier een procedure om het voorste datarecord uit een lineaire lijst te laten verwijderen: PROCEDURE Haal_voorste_element_uit_lijst (VAR Lijstkopwijzer: LIJSTWIJZER); VAR hulprecordwijzer : LIJSTWIJZER; IF LijstKopWijzer = NIL THEN write ('Lijst is leeg!') hulprecordwijzer:= LijstKopWijzer^.vervolg ; Dispose ( LijstKopWijzer ); LijstKopWijzer := hulprecordwijzer Op een vergelijkbare manier is het uiteraard mogelijk om eerst (b.v. in een gesorteerde lijst) op zoek te gaan naar een record (d.m.v. het identificerende gegeven ervan) en dan dat record uit de lijst te verwijderen (vergeet dan niet om via Dispose(..) de door dat te verwijderen record gealloceerde geheugenruimte weer vrij te geven). We geven hier een recursieve uitwerking van het probleem. PROCEDURE Verwijder_uit_Lijst( te_verwijderen: ELEMENT; VAR wijzer : LIJSTWIJZER); VAR huidige : LIJSTWIJZER ; { recursieve versie } IF wijzer = NIL THEN write ( 'Lijst is leeg!' ) huidige := wijzer ; IF huidige^.waarde = te_verwijderen {hebbes; dit element verwijderen!} THEN Wijzer := huidige^.vervolg ; Dispose ( huidige ) { geef geheugenplaats vrij } { laat pointer naar volgende wijzen} Verwijder_uit_Lijst ( te_verwijderen, wijzer^.vervolg ) Desgewenst is ook deze verwijder-procedure om te zetten naar een iteratieve variant. Een alternatieve aanpak zou ook als volgt kunnen zijn: eerst zoeken of het te verwijderen element in de lijst zit en zoja, te onthouden wáár en dan op die aangewezen plek het betreffende record er uit te werken. Indien je een gesorteerde lineaire lijst hebt, dan is het eenvoudig om na te gaan of een bepaalde waarde in een record van die lijst voorkomt. We geven daarvoor de volgende (recursief geformuleerde) functie: FUNCTION Zit_in_Gesorteerde_Lijst ( wijzer : LIJSTWIJZER ; zoekwaarde : INTEGER ; VAR positie : INTEGER ) : BOOLEAN ; IF wijzer = NIL THEN Zit_in_Gesorteerde_Lijst := FALSE IF zoekwaarde < wijzer^.waarde THEN Zit_in_Gesorteerde_Lijst := FALSE IF zoekwaarde = wijzer^.waarde THEN inc ( positie ) ; Zit_in_Gesorteerde_Lijst := TRUE 23

6 inc ( positie ) ; Zit_in_Gesorteerde_Lijst := Zit_in_Gesorteerde_Lijst( wijzer^.vervolg, zoekwaarde, positie ) Indien voorgaande functie als functiewaarde true oplevert, dan is hier via de VAR-parameter positie tevens te achterhalen op welke plaats in de lijst de bij oproep meegegeven zoekwaarde is aangetroffen (afhankelijk van de vraagstelling, zou je die aangetroffen plaats ook via een pointer-waarde kunnen terugspelen). Door het via een pointer terugspelen van de plaats waar in een gesorteerde lijst het record voorafgaande aan een te verwijderen record zit, dan is het daarna relatief eenvoudig om met wat pointer-algoritmiek dat record uit de lijst te verwijderen (via een toekenning van iets als vorig^.vervolg := vorig^.vervolg^.vervolg en - indien gewenst- het via dispose vrijgeven van de gealloceerde geheugenruimte) Dynamische Stack s en Queue s Stack s en Queue s worden nìet noodzakelijkerwijs, maar wèl in het algemeen als dynamische datastructuren (met pointers) gerealiseerd. Beide typen zijn op te vatten als speciale uitwerkingen van een lineaire lijst. De verschillen/specialiteiten zijn als volgt: Stack: een datastructuur waarbij toevoegingen en verwijderingen van gegevens(records) steeds van éénzelfde kant plaatsvinden; Queue: een datastructuur waarbij toevoegingen en verwijderingen van gegevens(records) aan verschillende kanten plaatsvinden. Toevoegen: Stack: Toevoegen: Queue: Afhalen Afhalen Stack s Zoals gezegd vinden hierbij toevoegingen en verwijderingen van gegevens(records) steeds van éénzelfde kant plaats. Men spreekt wel vaak van een LiFo-stack: Last in First out. Bekende kreten bij stacks zijn: pop en push. Deze kreten staan voor: Push : zet/bewaar een waarde op de stack; meestal geef je zo n waarde als parameter mee Pop : haal een waarde van de stack af (meestal zal die opgehaalde waarde een VAR-parameter zijn). Als we zo n stack implementeren al s een dynamische lineaire lijst (zie aan het begin van dit hoofdstuk), dan kunnen we de push -operatie heel eenvoudig implementeren: PROCEDURE Push ( VAR Stackwijzer : LIJSTWIJZER ; toe_te_voegen_waarde : ELEMENT ); Voeg_voor_aan_lijst_toe ( Stackwijzer, toe_te_voegen_waarde ) Uiteraard is het mogelijk deze procedure direct te schrijven, zonder gebruik te maken van de procedures zoals we die bij lineaire lijsten hebben gezien. Voor de pop -procedure kunnen we niet eenvoudig weg een aanroep van de eerder besproken procedure Haal_voorste_element_uit_Lijst doen, omdat die procedure slechts dat voorste element verwijderde, maar het niet als (bijvoorbeeld) VAR-parameter-waarde terug gaf naar de plaats van aanroep. Een ietwat omslachtige maar wel luie uitwerking kan de volgende aanpassing zijn: PROCEDURE Pop ( VAR Stackwijzer : LIJSTWIJZER; VAR opgehaald : ELEMENT ); IF Stackwijzer <> NIL THEN opgehaald := Stackwijzer^.waarde ; { en pas hierna: verwijder dat eerste record: } Haal_voorste_element_uit_lijst ( Stackwijzer ) 24

7 3.1.5 Queue s Bij Queue s vinden toevoegingen en verwijderingen van gegevens(records) aan verschillende kanten plaats: dit wordt vaak aangeduid met de FiFo-aanpak: First in, First out. Het zal erg inefficiënt worden om voor zo n Queue een eenvoudige lineaire lijst te gebruiken; we zullen dan vaak de gehele lijst moeten volgen om (bij keuze om achteraan toe te voegen en vooraan weg te halen) aan de staart een gegeven toe te voegen. Het is veel efficiënter om niet alleen naar de kop, maar ook naar de staart van de queue een pointer te hebben. Een variant op een dubbelgelinkte lijst zou hier dus goed bruikbaar voor zijn Practicumopdracht over lineaire lijsten In de I:Voorb2ld-directory tref je een relatief groot getypeerd gegevensbestand Strings.dat aan, van meer dan duizend gedeeltelijk (via random-functies) gevulde STRING s (het bestand is dus getypeerd als een FILE OF STRING ; per string zijn in dit getypeerde bestand dus steeds 25 Bytes gereserveerd). Maak nu een programma waarmee je het volgende kunt doen: alle strings uit het gegevensbestand inlezen en in een (op stringwaarde) gesorteerde lineaire lijst plaatsen de stringwaarden van de lijst-elementen in die gesorteerde volgorde kunt laten zien alle stringwaarden tenslotte in die gesorteerde volgorde laat wegschrijven naar een TEXT-bestand (b.v. onder de naam Strings.txt ; controleer of alles goed gegaan is door met een editor dit TEXT -bestand in te laden en te kijken of het gesorteerd is en uit hoeveel tekst(onzin)regels het bestaat. Klopt dat met het uit het oorspronkelijke bestand ingelezen aantal stringrecords? zorg ervoor, dat uiteindelijk alle eerder bezette geheugenruimte weer vrij is gegeven (en controleer door gebruik te maken van de functie MemAvail of je dit inderdaad gelukt is). Hint: beperk in eerste instantie je programma dusdanig, dat je alleen b.v. de eerste 8 strings uit het bestand inleest en er verder mee werkt (dat gaat wat sneller en je hebt bij het trace n wat meer overzicht in wat er gebeurt). Breid het daarna pas uit tot het verwerken van alle strings uit het volledige bestand. Wel kan het zijn dat je dan ontdekt, dat een recursief geformuleerde oplossing niet meer werkt omdat je stack overflow krijgt en dat je dus je oplossing zult moeten omzetten naar een iteratieve aanpak. 3.2 Binaire (zoek-) bomen In het algemeen kan een binaire boom gedefinieerd worden als een boom die steeds twéé mogelijke vervolgdelen heeft (die elk ook weer een binaire boom zijn). Uiteraard kan een binaire boom ook leeg zijn; d.w.z. de pointer naar de wortel van een boom kan NIL zijn. Anders gedefinieerd: een binaire boom is òf leeg (NIL), of bestaat uit een datarecord met daarin twéé pointervelden, die op elk hun beurt NIL kunnen zijn of naar een linker- of een rechterzijtak verwijzen. Zo n zijtak is ook weer een binaire boom. Als mogelijke record-definitie voor het opzetten van zo n boomstructuur geven we: 2 Wortel pointer naar linker vervolgtak pointer naar rechter vervolgtak Figuur 5 Algemene recordstructuur binaire boom TYPE ELEMENT = STRING[]; { of INTEGER e.d. ;} BOOMWIJZER = ^BOOMBLAD; BOOMBLAD = RECORD Waarde : ELEMENT; Links, Rechts : BOOMWIJZER 2 N.B. deze record-definitie, maar ook alle verdere behandelde Pascal-code over binaire bomen, kun je op de I: -drive in de Voorb2ld-directory aantreffen onder de naam BinBoom.pas. 25

8 waarbij het begin van zo n boomstructuur gevonden kan worden via een pointervariabele als: VAR Wortel : BOOMWIJZER; Een speciaal (maar voor ons interessant) geval is daarbij de binaire zoekboom; waarbij (recursief) vanuit een bepaalde knoop geredeneerd, de sleutelwaarden in de records van de linker vervolgboom steeds kleiner (of gelijk) zijn aan de waarden van die knoop beschouwde en waarbij sleutelwaarden van knopen in de rechter vervolgboom steeds groter zijn dan die in die knoop. Een voorbeeld van een concrete invulling van zo n binaire zoekboom is de volgende: / \ 4 8 / \ / \ / \ / \ / \ / \ NIL 3 NIL NIL NIL NIL NIL NIL / \ NIL NIL Duidelijk is hierin te zien, dat: elk knoop-record twéé (mogelijke) verwijzingen naar een volgend record heeft ( die NIL kunnen zijn); dat het linker vervolg-record steeds een kleinere waarde heeft dan het knooprecord zèlf en het rechter vervolg-record net een grotere waarde heeft. Voorgaande boomstructuur is op het beeldscherm afgedrukt met de procedure: PROCEDURE Toon_Boom ( tak : BOOMWIJZER ; xcoord, ycoord, diepte : BYTE ); VAR xnieuw,ynieuw,i : INTEGER; GotoXY(xcoord,ycoord); IF tak = NIL THEN write('nil') write ( tak^.waarde,'':3 ); GotoXY ( xcoord-1, ycoord+1 ); write ('/ \'); ynieuw := ycoord + 2; { ga naar positie linkerblad (diepte+1,xnieuw,ynieuw): } xnieuw := xcoord - 80 DIV ((diepte+1)*(diepte+1)); GotoXY(xnieuw+2,ycoord+1); FOR i:=xnieuw TO xcoord-4 DO write('_'); Toon_Boom ( tak^.links, xnieuw, ynieuw, diepte+1 ); { ga naar positie rechterblad ( diepte+1, xnieuw, ynieuw ): } xnieuw := xcoord + 80 DIV ((diepte+1)*(diepte+1)); GotoXY(xcoord+3,ycoord+1); FOR i:=xcoord TO xnieuw-4 DO write('_'); Toon_Boom ( tak^.rechts, xnieuw, ynieuw, diepte+1 ) die aangeroepen werd via: Toon_Boom ( wortel, 39, 1, 1 ); teneinde de gehele boom op het scherm te kunnen tonen. N.B. laat je hierbij niet al te veel afleiden door de opmaak-code (met GotoXY... etc.) maar richt je vooral op de vetgedrukte (en eventuele cursieve) delen binnen deze procedure. Vanwege de gebruikte lay out zullen grotere bomen helaas onoverzichtelijk op het scherm worden getoond. Heel wat gemakkelijker wordt zo n Toon -procedure als je je geen zorgen over de layout hoeft te maken. Als we slechts onder elkaar de gesorteerde (sleutel)waarden van de bladeren van de eerder gebruikte binaire zoekboom op het scherm willen laten afdrukken, dan kan dat eenvoudig via de volgende procedure: PROCEDURE Toon_Boomwaarden_in_Volgorde ( Tak : BOOMWIJZER ); IF Tak <> NIL THEN Toon_Boomwaarden_in_Volgorde ( Tak^.Links ); writeln ( Tak^.Waarde ); Toon_Boomwaarden_in_Volgorde ( Tak^.Rechts ) 2

9 Ga de werking van deze procedure na en let wederom op de recursieve formulering ervan Het toevoegen van elementen aan een binaire boom De vraag of een boom-in-opbouw een gewone binaire boom of een binaire zoek-boom wordt, hangt geheel af van de wijze waarop de bladeren (lees: records) in die boom worden toegevoegd. Als dat toevoegen op een gestructureerde manier gebeurt, waarbij kleinere sleutelwaarden in de linker boomtak geplaatst worden en grotere in de rechter boomtak (dit alles vergeleken bij de sleutelwaarde in het blad waar de vervolgrichting bepaald moet worden), dan hebben we te maken met een binaire zoekboom. We geven daarvoor hier de toevoeg-procedure voor een eenvoudige binaire zoek-boom: PROCEDURE Voeg_Toe_aan_Boom ( VAR Tak: BOOMWIJZER; nieuwe_waarde: ELEMENT); IF Tak = NIL THEN New ( Tak ); WITH Tak^ DO Waarde := nieuwe_waarde; Links := NIL; Rechts := NIL IF nieuwe_waarde >= Tak^.Waarde THEN Voeg_Toe_aan_Boom ( Tak^.Rechts, nieuwe_waarde ) Voeg_Toe_aan_Boom ( Tak^.Links, nieuwe_waarde ) Let op het recursief geformuleerde karakter van deze procedure Verwijderen van elementen uit een (gesorteerde) binaire zoekboom Het verwijderen van een element (een knoop of blad ) uit een binaire boom is complexer dan bijvoorbeeld het toevoegen van een element. Er kunnen zich bij zo n verwijderen vier verschillende situaties voordoen: de te verwijderen knoop heeft géén verdere vertakkingen (d.w.z. beide vervolgwijzers zijn NIL ) de te verwijderen knoop heeft één verdere vertakkingen (en één NIL-vervolgwijzer) de te verwijderen knoop heeft twéé simpele verdere vertakkingen (en géén NIL-vervolgwijzer) de te verwijderen knoop heeft twéé complexe vertakkingen, die beiden vertakte bomen zijn. a) 5 b) c) d) e) Figure 1 Het verwijderen van ' knopen'uit een binaire boom 9 9 We bespreken deze mogelijkheden aan de hand van de volgende in de figuren geschetste voorbeelden. In de eerste figuur is aangegeven wat het resultaat moet zijn als onze nog op te stellen verwijder-algoritme op de boom wordt losgelaten, om allereerst (onderdeel a => b) de knoop met de waarde 4 te verwijderen en daarna achtereenvolgens de knopen met de waarden 3, 8 en 5. Omdat we ons probleem recursief willen oplossen, worden te verwijderen knopen aangeduid via een pointer, die bereikbaar is via de wortelwijzer van de boom. De eerste verwijdering van die knoop met waarde 4 is er een van het genoemde eerste type (deze knoop heeft géén verdere vertakkingen) en is eenvoudig uit te voeren: gooi die waarde weg (via dispose) en zet de oude pointer (vanuit de knoop met waarde 3 ) ernaartoe op NIL. 27

10 De tweede verwijdering van de knoop met waarde 3 is er een van het tweede type ( één verdere vertakking). We kunnen dan de waarde van de knoop vervangen door die van de eraan hangende volgende knoop; of beter: de pointer vanuit de bovenliggende knoop (hier: 5 ) ernaartoe, vervangen door een pointerwaarde naar de vervolgknoop (lees: 1 ) en de door de te verwijderen knoop bezette geheugenruimte vr ij geven (via dispose). De bij c) en d) aangeduide verwijderingen zijn beide van het genoemde derde type (met twéé simpele verdere vertakkingen, die beide of losse bladeren òf slechts aan één kant vertakte bomen zijn). In dit geval kunnen we ervoor kiezen om de waarde(n) van de te verwijderen knoop te vervangen door die van de linker vervolgknoop of van de rechter vervolgknoop (we hebben in onze implementatie gekozen voor links ). Een speciaal probleem doet zich echter voor als we beginnen met het verwijderen van de knoop met waarde 5, die zowel een vertakte linker als een vertakte rechter onderboom heeft. Om de ordening in de boom in stand te houden, zullen we iets speciaals moeten doen met de knopen met waarden 1, 3 en 4 (als we ervoor kiezen om iets met de linker onderboom te doen). We moeten dan (zie volgende figuur) -om de ordening te behouden- de waarde van 4 op de plaats van de te verwijderen knoop 5 plaatsen. Indien de onderbomen nog verder (naar beneden) vertakt zijn, dan moeten we bij onze keuze voor doe iets met de linker onderboom (de waarde(n) van) het meest rechtse blad uit die linker onderboom op de plaats van de te verwijderen knoop plaatsen. f) 5 g) Figure 2 Verwijderen van een knoop bij 2 vertakte onderbomen We geven hierna de bijbehorende (recursief geformuleerde) algoritme (met een lokale hulpprocedure voor het implementeren van het besproken probleem bij twee vertakte onderbomen): PROCEDURE Verwijder_uit_Boom ( VAR Tak : BOOMWIJZER; oude_waarde : ELEMENT); VAR hulpwijzer : BOOMWIJZER ; PROCEDURE Vervang_deze_knoop_door ( VAR Knoop : BOOMWIJZER ) ; IF Knoop^.Rechts <> NIL THEN { pak knoop verder naar rechts } Vervang_deze_knoop_door ( Knoop^.Rechts ) hulpwijzer^.waarde := Knoop^.Waarde ; hulpwijzer := Knoop ; Knoop := Knoop^.Links IF Tak = NIL THEN write ( 'Waarde komt niet voor in boom!' ) IF oude_waarde > Tak^.Waarde THEN Verwijder_uit_boom ( Tak^.Rechts, oude_waarde ) IF oude_waarde = Tak^.Waarde THEN { hebbes; deze knoop moet verwijderd worden } hulpwijzer := Tak ; IF hulpwijzer^.rechts = NIL THEN Tak := hulpwijzer^.links IF hulpwijzer^.links = NIL THEN Tak := hulpwijzer^.rechts Vervang_deze_knoop_door ( Tak^.Links ) ; Dispose ( hulpwijzer ) Verwijder_uit_boom ( Tak^.Links, oude_waarde ) 28

11 3.2.3 Het (snel) opzoeken van waarden in een binaire zoekboom Binaire zoek-bomen worden in de praktijk gebruikt voor het zeer snel kunnen opzoeken van waarden. Hier volgt de invulling van een mogelijke functie voor het laten bepalen of een bepaalde waarde wel/niet in een binaire zoek-boom voorkomt: FUNCTION Waarde_in_boom ( Tak: BOOMWIJZER; zoekwaarde: INTEGER ) : BOOLEAN; IF Tak = NIL THEN Waarde_in_boom := FALSE IF Tak^.Waarde = zoekwaarde THEN Waarde_in_boom := TRUE IF Tak^.Waarde < zoekwaarde THEN Waarde_in_boom := Waarde_in_boom ( Tak^.Rechts, zoekwaarde) Waarde_in_boom := Waarde_in_boom ( Tak^.Links, zoekwaarde ) Voor het héél snel kunnen vinden van waarden in een binaire zoek-boom is het nodig dat de boom min of meer uitgebalanceerd is; dat wil zeggen dat in elke knoop de diepte van de linkertak en die van de rechtertak hooguit één eenheid van elkaar verschillen. In zo n uitgebalanceerde binaire boom met een diepte van 10 kunnen in totaal ruim duizend gegevensrecords ( knopen ) geplaatst worden; het kunnen plaatsen van een miljoen records vereist een diepte van 20. Voor het laten bepalen of een binaire boom wel dan niet uitgebalanceerd is, kunnen we vrij gemakkelijk de minimale en de maximale diepte van de verschillende takken van de boom laten bepalen. We geven hierna een recursieve uitwerking daarvan. FUNCTION Grootste_Diepte ( Tak : BOOMWIJZER ) : INTEGER ; IF Tak = NIL THEN Grootste_Diepte := 0 Grootste_Diepte := 1 + Maximum ( Grootste_Diepte ( Tak^.Rechts), Grootste_Diepte ( Tak^.Links) ) FUNCTION Kleinste_Diepte ( Tak : BOOMWIJZER ) : INTEGER ; IF Tak = NIL THEN Kleinste_Diepte := 0 Kleinste_Diepte := 1 + Minimum ( Kleinste_Diepte( Tak^.Rechts), Kleinste_Diepte( Tak^.Links) ) De door de eerste functie aangeroepen hulpfunctie Maximum (met door de tweede functie als lichte va riant: Minimum ) is: FUNCTION Maximum ( getal1, getal2 : INTEGER ) : INTEGER ; IF getal1 > getal2 THEN Maximum := getal1 Maximum := getal2 Het uitbalanceren van bomen (vooral vaak nodig na toevoegingen of verwijderingen van records uit de boom) valt echter buiten het kader van deze cursus (voor geïnteresseerden: zie b.v. de klassieker van Niklaus Wirth: Algoritmen und Datastrukturen of de engelstalige versie van dit boek). Bekijk het volgende voorbeeld om een idee te krijgen van hoe zo n uitbalanceren van bomen in zijn werk gaat. h) i) j) Figure 3 Het uitbalanceerproces van een binaire zoekboom 29

12 Voor alledrie de getoonde bomen geldt, dat het (geordende) zoekbomen zijn. De linker (en de middelste) boom heeft echter een kleinste en een grootste diepte van resp. 2 en 4 en is nìet uitgebalanceerd. In de figuur wordt de linker boom in twee stappen, via zogenaamde links - en rechts -rotaties, omgezet in de wèl uitgebalanceerde rechter boom. Voor de benodigde algoritmiek verwijzen we naar de literatuur. Uitgebalanceerde zoekbomen noemt men (naar hun ontdekkers Adelson -Velskii en Landis) ook wel AVL-bomen Complexere recordstructuur op de knopen/bladen van een binaire boom Uiteraard is het mogelijk om de recordstructuur van de boombladeren voor wat betreft het gegevensdeel veel complexer te maken. In het volgend plaatje is b.v. zowel de recordstructuur aangepast (om ook het aantal voorkomens van een sleutelwaarde te onthouden) en de eerder gegeven toon boom -procedure: (2x) / \ 3(4x) 9(2x) / \ / \ 2 5(2x) 8 NIL / \ / \ / \ NIL NIL 4(2x) NIL 7(2x) NIL / \ / \ NIL NIL NIL NIL Let erop, dat ook deze boom nìet uitgebalanceerd is (met minimale en maximale diepte resp.: 2 en 4 ). Op een soortgelijke manier zou je bijvoorbeeld studentgegevens in een zoekboom kunnen hangen, waarbij als sleutelwaarde het studentnummer wordt gebruikt. Als je dan op studentnoemer zoekt, kom je bij een ergens in de boom gehangen compleet record met overige studentgegevens terecht (die je op kunt vragen en/of waar je veranderingen in kunt aanbrengen). 3.3 Dubbelgelinkte (pointer-)lijsten In een dubbelgelinkte (pointer-) lijst is elk opgenomen record via een pointer zowel verbonden met een volgend als (door een tweede pointer) met een voorgaand record. Schematisch kunnen we dat als volgt weergeven: Data NIL Data Data Data NIL Kop Wijzer? Staart Figure 4 (mogelijk) voorbeeld van een dubbelgelinkte lijst Een dergelijke datastructuur kan opgebouwd worden via een volgende TYPE-definitie: TYPE DGLIJSTWIJZER = ^DGLIJSTRECORD ; DGLIJSTRECORD = RECORD Waarde : ELEMENT ; Volgend, Vorig : DGLIJSTWIJZER Het voordeel van zo n dubbelgelinkte lijst is, dat je vanuit een gegevensrecord zowel naar het volgende als naar het vorige record kunt gaan. Toevoegingen, wijzigingen en -vooral- verwijderingen kunnen hierdoor veel gemakkelijker plaatsvinden. De lijst is zowel via de kop als via de staart benaderbaar. Ook is het bij dit type lijst mogelijk om een hulpwijzer op een record in de lijst te laten wijzen en dan dat record te verwijderen door de pointers in het voorafgaande en het volgende record aan te passen. 30

13 N.B. 1) In de geschetste figuur vormen het eerste en het laatste record een uitzondering op deze net gegeven omschrijving; (alleen) in deze twee records komen NIL-pointers voor. Een veel gebruikte variant is daarom, om als eerste en als laatste record een zogenaamd sentinel-record ( schildwacht ) te plaatsen en die schildwacht -records circulair naar elkaar te laten verwijzen. Het eerste sentinel-record wordt dan een onmogelijk lage sleutelwaarde gegeven (zoals 0000 of aaaa of -MAXINT of zoiets) en het laatste een onmogelijk hoge sleutelwaarde ( 9999, +MAXINT, zzzzz of iets in die trant). Er kan dan immers vanwege dat circulaire niet meer gecontroleerd worden op het bereiken van een NILwaarde (die zijn er dan immers niet meer). 2) Er zijn diverse varianten van dubbelgelinkte lijsten mogelijk. In principe zou één enkele pointer naar een record van een dubbelgelinkte lijst voldoende zijn om de de gehele lijst (naar voren en naar achteren) te kunnen doorlopen. Een veel gehanteerde aanpak is om één pointer naar de kop te laten wijzen, één pointer naar de staart en [minimaal] nog eentje naar het record waar op dat moment de aandacht op gevestigd is. We geven hier een uitgewerkt voorbeeld van het werken met dubbelgelinkte lijsten. We doen dat met dezelfde definitie van een Studentrecord als in het vorige hoofdstuk en gaan (via een voor een inlezen van records uit een getypeerd bestand) deze records in een dubbelgelinkte lijst plaatsen. We geven eerst het aansturend hoofdprogramma en vervolgens de inhoud van een unit Lijsten : Program TestLijst; { Opdracht over het werken met pointers} Uses Crt, Studenten, Lijsten; VAR bestand : FStudent; student : RStudent; OpenStudentBestand ( bestand ); WHILE NOT EOF( bestand ) DO Read ( bestand, student ); Add( student ); { While }; Close( bestand ); Show;. Unit Lijsten; Interface Uses Studenten, Crt; TYPE PEStudent = ^REStudent ; REStudent = RECORD last : PEstudent ; stud_ptr : PStudent ; next : PEStudent PROCEDURE Add ( student : RStudent ) ; PROCEDURE Show ; In deze recorddefinitie zien we duidelijk, dat een REStudent-record uit drie pointervelden bestaat: een last - en een next -pointer staan naar respectievelijk een vorig en een volgend (REStudent-) record en een stud_ptr - pointer verwijst naar een studentrecord (dat hadden we toch al ; we hadden hier natuurlijk geen pointerveld naar zo n studentr ecord hoeven op te nemen, dat had ook b.v. een veld deze_student van het type Rstudent kunnen zijn). De functie van die stud_ptr wordt in de volgende figuur weergegeven: 31

14 De functie van het last - en het next -pointerveld wordt hierna geschetst. Naast de figuur wordt (bij het implementatie-deel van de procedure Init ) de code gegeven voor het initialiseren van deze dubbelgelinkte lijst, waarbij aan het begin én aan het einde die schilwacht-records worden geplaatst. Implementation VAR kop, wijzer, staart : PEStudent; PROCEDURE Init ( VAR kop, wijzer, staart : PEStudent); {Maak schildwachtknopen:} New ( kop ); New(kop^.stud_ptr); InitStudent(kop^.stud_ptr^); { deze sentinel heeft naam zo klein mogelijk; immers } New(staart); New(staart^.stud_ptr); InitStudent(staart^.stud_ptr^ ); { Laatste schildwacht met naam alfabetisch zo groot mogelijk: } staart^.stud_ptr^.naam := 'zzzzz'; wijzer := staart; { Verbind schildwachten circulair: } kop^.next := staart ; kop^.last := staart ; staart^.next := kop ; staart^.last := kop { Init }; PROCEDURE Add ( student : RStudent ); VAR p : PEStudent; WHILE ( wijzer^.stud_ptr^.naam > student.naam ) DO wijzer := wijzer^.last; WHILE ( wijzer^.stud_ptr^.naam <= student.naam ) DO wijzer := wijzer^.next; New ( p ); New ( p^.stud_ptr ); p^.stud_ptr^ := student; { kopieer de parameter-record-inhoud } p^.next := wijzer; p^.last := wijzer^.last; wijzer^.last^.next := p; wijzer^.last := p; wijzer := p; { Add }; PROCEDURE Show; VAR p : PEStudent; p := kop^.next; WHILE p <> staart DO ToonStudent( p^.stud_ptr ); 32

15 p := p^.next; { While }; { Show }; { Initialisatie Lijsten } Init ( kop, wijzer, staart ); { Unit Lijsten }. Het tussen de aan de uiteinden van de lijst staande schilwacht-records toevoegen van een nieuw record gaat (zie code in voorgaande procedure Add schematisch als volgt: new(p); new(p^.stud_ptr); p^.stud_ptr^ := student; En vervolgens: p^.next := wijzer; p^.last := wijzer^.last; wijzer^.last^.next := p; wijzer^.last := p; wijzer := p; 33

16 3.3.1 Practicumopdracht over binaire zoekbomen In de taal Pascal bestaan een aantal gereserveerde woorden, zoals,, FOR, etc.. In deze opdracht moet je eerst al deze gereserveerde woorden in een binaire zoekboom plaatsen en daarvan gebruik maken om van een (via de bestandsnaam aan te duiden) Pascal-programma te laten analyseren op het (hoe vaak) voorkomen van elk van deze woorden. De (uitgebalanceerde) zoekboom ziet er als volgt uit: LABEL / \ SET / \ / \ CONST FUNCTION PROCEDURE UNTIL / \ / \ / \ / \ DO FILE IF NIL RECORD TO WHILE / \ / \ / \ / \ / \ / \ / \ / \ ARRAY CASE DIV DOWNTO FOR GOTO IN MOD OF PROGRAM REPEAT THEN TYPE VAR WITH In de I:voorb2ld-directory tref je een TEXT-bestand Psleutel.txt aan, waarin deze bekende PASCAL - gereserveerde woorden, per regel steeds één woord in hoofdletters, zijn opgeslagen. Maak nu een programma waarmee je het volgende kunt doen: laat de gegeven gereserveerde woorden inlezen en plaats ze in een binaire zoekboom, waarbij in z on gegevensrecord niet alleen het betreffende woord, maar voorlopig ook een 0 als reeds gevonden aantal_voorkomens van dat woord is opgenomen (zie bovenstaande schetsmatige boomstructuur); laat de gebruiker nu de naam van een reeds bestaand Pascal-programma-bestand intikken; het programma moet nu regel-voor-regel van het aangeduide Pascal-programma-bestand inlezen, in het computergeheugen (d.w.z. in gewone statische variabelen) per regel de (losse) woorden isoleren, ze om zetten in hoofdletters en tenslotte van alle (in hoofdletters omgezette) woorden in de eerder opgebouwde zoekboom nagaan of het betreffende woord een gereserveerd Pascal-woord is. Indien dat zo is, dan moet in de boom bij dat woord de waarde in het gegevensveld met het aantal voorkomens van dat woord met één verhoogd worden. laat tenslotte een alfabetisch gerangschikt overzicht van gereserveerde Pascal-woorden en het aantal keren dat elk woord in het programma is aangetroffen op het scherm verschijnen. verzin zèlf een manier om de door de zoekboom gealloceerde geheugenruimte vrij te geven en implementeer die (en test uit). N.B. de volgorde van de woorden in het bestand Psleutel.txt is reeds zodanig, dat bij normaal opbouwen de verkregen binaire zoek-boom uitgebalanceerd is. 34