1. Uitleg Stack

Wat is een Stack?

In de programmeerwereld wordt een Stack gebruikt om gegevens op te slaan volgens het LIFO-principe (Last In, First Out). Dit betekent dat het laatste element dat aan de Stack wordt toegevoegd, als eerste wordt verwijderd. Denk aan een stapel borden: je kunt alleen het bovenste bord pakken en nieuwe borden bovenop leggen.

Stacks worden veel gebruikt in programmeerlogica, bijvoorbeeld voor het bijhouden van method-aanroepen, het ongedaan maken van acties, of het evalueren van expressies. Zonder een Stack zou het lastiger zijn om gegevens georganiseerd en tijdelijk op te slaan op een manier die logisch werkt voor dit soort scenario’s.

Casus

Stel je hebt een teksteditor waarin je wijzigingen aanbrengt; een Stack kan worden gebruikt om elke wijziging op te slaan, zodat je met een undo-actie de laatst gemaakte wijziging gemakkelijk kunt terugdraaien.

Hoe zit een Stack in elkaar?

Een Stack heeft een specifieke structuur die draait om twee kernoperaties: push (toevoegen van een element) en pop (verwijderen van het bovenste element). De Stack volgt het LIFO-principe (Last In, First Out), wat betekent dat het laatst toegevoegde element als eerste wordt verwijderd.

Belangrijk om te weten is dat een Stack altijd van bovenaf wordt benaderd: je kunt alleen het bovenste element bekijken of verwijderen (figuur 1).

Figuur 1: Werking van een Stack gevisualiseerd

Codevoorbeeld

// Een nieuw Stack aanmaken
Stack<int> stack = new Stack<int>();
 
// Elementen aan de Stack toevoegen
stack.Push(1);
stack.Push(2);
stack.Push(3);
 
// Elementen van de Stack verwijderen
int top = stack.Pop(); // Verwijdert 3 en stopt dit element in een variabele
 
// Bovenste element bekijken
int peek = stack.Peek(); // Stopt 2 in de variabele maar verwijdert het niet

Hoe gebruik je een Stack?

De causaliteit in een Stack komt voort uit de vraag: “Wat gebeurt er als een element wordt toegevoegd of verwijderd?” Het gebruik van een Stack stelt een programma in staat om gegevens tijdelijk op te slaan en te manipuleren volgens het LIFO-principe (Last In, First Out), wat leidt tot een logische volgorde van acties. Bijvoorbeeld, als je een nieuw element toevoegt, wordt het bovenop de Stack geplaatst; als je een element verwijdert, haal je het bovenste element weg.

Verder zijn er nog een aantal toepassingen waarvoor een Stack geschikt is, zoals:

• Expressie validatie (postfix notatie)
• Valideren haakjes
• Memory management
• Call Stack

Bewerkingen op een Stack

Push

Push zorgt ervoor dat er een nieuw element bovenop de Stack wordt geplaatst.

Stack<string> stack = new Stack<string>();
 
stack.Push("Eerste");
stack.Push("Tweede");
stack.Push("Derde");
Console.WriteLine(string.Join(", ", stack)); // Output: Derde, Tweede, Eerste

Pop

Pop zorgt ervoor dat het bovenste item uit de Stack wordt gehaald. Het is mogelijk om deze waarde ook op te slaan in een variabele en uit te lezen.

Stack<string> stack = new Stack<string>();
 
stack.Push("Eerste");
stack.Push("Tweede");
 
string bovensteElement = stack.Pop();
 
Console.WriteLine(bovensteElement); // Output: Tweede

Count

Count telt het aantal elementen in de Stack.

Stack<string> stack = new Stack<string>();
 
stack.Push("Eerste");
stack.Push("Tweede");
stack.Push("Derde");
stack.Pop();
 
int aantal = stack.Count;
 
Console.WriteLine(aantal); // Output: 2

Peek

Peek kijkt naar wat het bovenste element is, maar haalt niet het element van de Stack af

Stack<string> stack = new Stack<string>();
 
stack.Push("Eerste");
stack.Push("Tweede");
stack.Push("Derde");
 
string bovenste = stack.Peek();
Console.WriteLine(bovenste); // Output: Derde

Clear

Clear zorgt ervoor dat de hele Stack geleegd wordt.

Stack<string> stack = new Stack<string>();
 
stack.Push("Eerste");
stack.Push("Tweede");
stack.Push("Derde");
 
int aantalMetElementen = stack.Count;
Console.WriteLine(aantalMetElementen); // Output: 3
 
stack.Clear();
 
int aantalZonderElementen = stack.Count;
Console.WriteLine(aantalZonderElementen); // Output: 0

---

Volgende stap: Stappen Stack