Een gelinkte lijst in C#

Transcriptie

1 Een gelinkte lijst in C# In deze tutorial ga demonstreren hoe je een gelinkte lijst kan opstellen in C#. We gaan een klasse schrijven, die een gelijkaardige functionaliteit heeft als een ArrayList, namelijk dat je er om het even hoeveel en om het even welk object aan kan toevoegen. Let wel (ik wil er nadruk op leggen) : onze klasse zal niet gelijk zijn aan de ArrayList klasse, maar enkel een gelijkaardige functionaliteit bieden, in die mate dat je er om het even welk type object aan kan toevoegen.

2 1. Een beetje theorie omtrent gelinkte lijsten Een gelinkte lijst is in feite een reeks objecten (instanties van een klasse), die via een pointer (reference genoemd in C#) met elkaar gelinkt zijn. Laat ons zo n object een naam geven: LinkedListItem. Typisch zal zo n LinkedListItem object ook een reference naar zekere data bevatten. Hier een grafische weergave van een simpele gelinkte lijst: LinkedListItem nextitem (reference) DataRef LinkedListItem nextitem (reference) DataRef... LinkedListItem nextitem (reference) DataRef Data Data Data null Het laatste element (object van type LinkedListItem) van de gelinkte lijst heeft typisch een reference (pointer) die wijst naar null. Zo geven we het einde van de lijst aan. Veelal wordt ook een reference gebruikt, die we een cursor noemen. Deze cursor wordt gebruikt om te itereren doorheen de gelinkte lijst. Om het makkelijk te zeggen; de cursor kan dus verwijzen naar om het even welke LinkedListItem binnen onze gelinkte lijst. We gaan deze gebruiken om gegevens op te zoeken en op te vragen uit onze gelinkte lijst. Korte terminologie: Een element poppen (Pop), betekent een element opvragen en meteen verwijderen uit de gelinkte lijst. Bij een queue is dit het eerste element, bij een stack het laatste. Een element pushen (Push), betekent een element toevoegen aan de lijst. Zowel bij een stack als een queue worden elementen op het einde van de lijst toegevoegd. In ons codevoorbeeld gebruiken we de methode Add om een element te pushen.

3 2. Een stack of een queue WATTE? De techniek die ik in deze tutorial beschrijf is de single linked list, een enkelvoudige gelinkte lijst dus. Van dit type gelinkte lijst bestaan er 2 varianten, namelijk de stack en de queue. Een stack: Een stack is gebaseerd op het principe last in, first out. Het laatst toegevoegde element zal het eerste element zijn dat we kunnen opvragen. Een queue: Een queue is gebaseerd op het principe first in, first out. Het eerste element van de lijst zal het eerste element zijn dat we kunnen opvragen. Ons voorbeeld (later in dit document): De voorbeeldcode lager in deze tutorial zal een gelinkte lijst beschrijven, die in feite een combinatie (en ietwat uitgebreider) is van stack en queue types. Wat we in de voorbeeldcode proberen te bereiken is een soort van collectie maken, waarin we om het even welk dataobject in kunnen opslaan (we gebruiken string in het voorbeeld, maar om het even welk ander object is ook mogelijk). Noot: (Hashtables en Binary Trees) Er bestaan nog enkele geavanceerdere typisch gelinkte lijst, zoals de hashtable en de binary tree, maar die zijn geen enkelvoudige gelinkte lijsten. Hashtables en binary trees gaan hun elementen in een ietwat intelligente manier gaan opslaan, zodat deze vlugger doorzoekbaar zijn. We gaan in deze tutorial niet al te ver in op deze types gelinkte lijst, maar als je de theorie achter queue en stack gelinkte lijsten begrijpt houdt er niks je tegen om te experimenteren met hashtables en binary trees. Wel wens ik de definitie van hashtables en binary trees geven: Hashtable: Dit is in feite een array van enkelvoudige gelinkte lijsten. De array index kan gebruikt worden om de gegevens intelligent op te slaan in één van de gelinkte lijsten van de hashtable. Een toe te voegen element wordt aan het begin van één van de gelinkte lijsten toegevoegd. Binary Tree: Een binary tree heeft een boomstructuur. Typisch heeft ieder LinkedListItem binnen een binary tree een reference naar links en rechts. Zo kunnen alle gegevens die je toevoegt logisch geordend worden in de boomstructuur. Het mag duidelijk zijn dat het opzoeken van een element binnen een boomstructuur over het algemeen veel vlugger zal werken dan in de andere types gelinkte lijst. Dit type gelinkte lijst is echter ook het ingewikkeldst om te programmeren. Noot hierbij: Er bestaan ook binary trees met meer dan 2 references, zoals de quadtree en de octree, die veel gebruikt worden voor scene graphs in game design.

4 3. De klassen LinkedList en LinkedListItem We gaan 2 klassen maken. De ene klasse zal LinkedList noemen, deze zal de methoden bevatten om onze gelinkte lijst te bewerken. De tweede klasse zal LinkedListItem noemen, het zijn de instanties van deze klasse die de reeks verbonden objecten van de gelinkte lijst gaan zijn. Start een nieuw C# windows application project in Visual Studio. Voeg een nieuwe klasse toe aan het project, noem deze LinkedList. Boven in het codevenster voegen we zelf de definitie voor onze klasse LinkedListItem toe (zorg ervoor dat je dit buiten de klasse LinkedList, maar wel binnen de namespace van je project doet). Neem de code over van volgende schermafdruk: De klasse LinkedListItem bevat slechts 2 fields. nextitem : Bij een gedefinieerd object van deze klasse zal de reference nextitem een reference bevatten naar het volgende element in onze gelinkte lijst (zie de figuurweergave in hoofdstuk 1). Data : De reference Data zal een reference bevatten naar het data-object dat we opslaan in onze gelinkte lijst. Bij het programmeren van gelinkte lijsten moet je ALTIJD in gedachte houden dat we een serie objecten definiëren die in feite geen reference op de stack hebben. De objecten zijn alle gealloceerd op de heap. Al de objecten zijn met elkaar verbonden via een reference (nextitem), en we hebben natuurlijk wel een gekend eerste object, waarnaar we een reference instellen, namelijk de reference Start (zie verder in dit document). In ons voorbeeld gebruiken we ook een reference naar het laatste element van de gelinkte lijst, en gebruiken we een cursor (een reference naar om het even welk object van type LinkedListItem) om doorheen de lijst te itereren.

5 Nou, dat was nogal simpel om die klasse LinkedListItem te maken!? Niet gevreesd, de klasse LinkedList is veel ingewikkelder - Eerst en vooral gaan we de constructor en de fields voor onze klasse gaan opstellen. public class LinkedList //nodige references private LinkedListItem Start; //reference naar het eerste LinkedListItem private LinkedListItem Cursor; //reference naar het huidige LinkedListItem private LinkedListItem LastItem; //reference naar het laatste LinkedListItem //nodige properties private int ilinkedlistitemcount = 0; //we starten met 0 LinkedListItem items public int Length //property om de huidige lengte van onze list op te vragen get return ilinkedlistitemcount; /// <summary> /// Constructor : initializeren van onze lijst /// </summary> public LinkedList() SetSartupValues(); /// <summary> /// Deze methode stelt de startwaarden voor de gelinkte lijst in /// </summary> private void SetStartupValues() //startwaarden instellen ilinkedlistitemcount = 0; Start = null; Cursor = Start; LastItem = Start;

6 We hebben 3 references naar een object van type LinkedListItem nodig, twee om het eerste (Start) en laatste (LastItem) object in de lijst te kunnen onthouden, en één om als iterator (Cursor) te gebruiken. We maken een property aan, die in samenwerking met een private integer variabele de lengte van onze lijst bijhoudt. In de constructor van de LinkedList klasse doen we aanroep naar de methode SetStartupValues om de startwaarden voor onze references en lijstlengte in te stellen.

7 4. Een object (LinkedListItem) toevoegen aan onze gelinkte lijst Figuur: Een object pushen op onze gelinkte lijst LastItem nieuwlinkedlistitem... LinkedListItem nextitem (reference) DataRef nextitem (reference) DataRef Data Data null Nu gaan we over naar de methode die elementen kan toevoegen na het laatste element in onze lijst. (deze methode Add is te vinden op de volgende pagina) We wensen dus een data-object toe te voegen aan onze lijst. In ons geval gaan we strings toevoegen, maar omdat we gebruik maken van een reference van het type object kunnen we in feite om het even welk object toevoegen aan onze lijst. (vervolgt)

8 We krijgen een object-reference mee als parameter bij onze methode Add. We beginnen met het instantiëren van een nieuw object van het type LinkedListItem, waarna we binnen het object nieuwlinkedlistitem de reference (Data) instellen op het data-object dat we toevoegen. (Herinner je, dat we op de heap werken, we verwijzen dus simpelweg naar een data-object dat op de heap gealloceerd staat). Als dit nieuwe LinkedListItem object het eerste object is in onze lijst, dan moeten we onze Start en LastItem references instellen op dit object, anders voegen we het nieuwe object toe na het huidig laatste object in onze lijst : LastItem.nextItem = nieuwlinkedlistitem; Waarna we het laatste element moeten instellen op het nieuwe object, omdat dit nu als laatste in onze lijst voorkomt: LastItem = LastItem.nextItem; NOOT: Lees het commentaar bij volgende code eens goed, die verklaart alles wat er gebeurt. Noot: Begrijp je onderstaande code niet, dan stel ik je voor dat je je best eerst eens verdiept in de onderwerpen stack- en heap-allocatie van variabelen en objecten. (vervolgt)

9 public bool Add( object listdata ) //Zowel stacks als queues voegen nieuwe elementen achteraan de lijst toe. try //Nieuw object instantiëren om in onze lijst te plaatsen LinkedListItem nieuwlinkedlistitem = new LinkedListItem(); //We voegen het object achteraan toe, dus zal de reference naar het volgende object op //null moeten staan. nieuwlinkedlistitem.nextitem = null; //We stellen de reference in naar de data (op de heap) voor ons LinkedListItem // omdat we objecten van het type object kunnen toevoegen, // kunnen we in feite om het even welk type object toevoegen. nieuwlinkedlistitem.data = listdata; //Als dit ons eerste LinkedListItem is, moeten we ook de Start reference correct instellen if(this.length == 0) //Start verwijzen naar het nieuwe LinkedListItem Start = nieuwlinkedlistitem; //De reference LastItem instellen LastItem = nieuwlinkedlistitem; //length +1 ilinkedlistitemcount++; else //Anders moeten we het nieuwe LinkedListItem toevoegen aan de lijst, na het //laatste element //nieuw LinkedListItem achteraan toevoegen LastItem.nextItem = nieuwlinkedlistitem; //Reference LastItem op laatste element instellen LastItem = LastItem.nextItem; //length +1 ilinkedlistitemcount++; //Indien dit gelukt is, true teruggeven return true; catch(exception ex) //Indien er een fout optreedt, schrijven we de foutboodschap naar console, // en geven we false terug. Console.WriteLine( ex.message ); return false;

10 5. Een object (LinkedListItem) poppen uit onze gelinkte lijst In hoofdstuk 1 zagen we reeds de betekenis van Pop en Push bij gelinkte lijsten. In hoofdstuk 4 maakten we de methode Push, met dat verschil dat we ze Add noemden. In dit hoofdstuk demonstreer ik hoe je een element kan poppen uit de gelinkte lijst, en meteen de Data-reference binnen het LinkedListItem object teruggeven. Onderstaande besproken code handelt omtrent hoe we een object poppen uit een gelinkte lijst op de manier van een Queue (zie hoofdstuk 2). We gaan dus het eerste element uit de lijst poppen. public object PopQueueItem() if(this.length == 0) return null; //er zijn geen elementen in de lijst try //We hebben het allereerste element in onze lijst nodig Cursor = Start; //Start instellen op het volgende element. Start = Start.nextItem; //Het object uit de lijst halen Cursor.nextItem = null; //Length property aanpassen ilinkedlistitemcount--; //Het element teruggeven return Cursor.Data; catch(exception ex) Console.WriteLine(ex.Message); return null; We zetten onze iterator (Cursor) op het eerste element van de lijst, en zetten de Start reference op het eerstvolgende element in onze lijst. Wanneer de Start reference opnieuw ingesteld is, kunnen we het object waar Cursor nu naar wijst uit de lijst halen door de reference nextitem op null te zetten. Er rest ons slechts de reference naar de Data terug te geven.

11 Noot: In de sourcecode die u ook kan downloaden zijn er meer mogelijkheden (zoals een object middenin de gelinkte lijst poppen, gelinkte lijst type stack poppen, ) aanwezig. In deze tutorial ga ik echter slechts in op het Pushen en Poppen zoals bij een gelinkte lijst van het type queue. De downloadbare broncode bevat een Visual Studio project (Windows Forms Application), waarvan de broncode goed gecommentarieerd is. Mits het begrijpen van deze 2 basistechnieken (pushen en poppen) zou je geen problemen mogen hebben met het begrijpen van de andere methoden. Veel plezier. Kris.