Data Structures 101: Arrays – Een visuele inleiding voor beginners

Leer de gegevensstructuren kennen die je elke dag gebruikt.

👋 Welkom! Laten we beginnen met wat vitale context. Laat me je dit vragen:
✅ Luistert u naar muziek op uw smartphone?
✅ Houdt u een lijst met contacten bij op uw telefoon?
✅ Heeft u ooit een leaderboard gezien tijdens een wedstrijd?

Als uw antwoord “ja” is op een van deze vragen, dan is het bijna zeker dat u arrays hebt gebruikt en dat u het niet eens wist! 😃 Arrays zijn zeer krachtige gegevensstructuren waarin lijsten van elementen worden opgeslagen. Ze hebben eindeloze toepassingen. Ze zijn erg belangrijk in de wereld van de informatica.

In dit artikel leer je de voor- en nadelen van arrays, hun structuur, bewerkingen, en use cases.

Let’s begin! 👍

🔎 Deep Dive Into the Basic Structure of Arrays

Om te begrijpen hoe ze werken, is het erg handig om het geheugen van uw computer te visualiseren als een raster, net als het raster hieronder. Elk stukje informatie wordt opgeslagen in een van die kleine elementen (vierkantjes) die het raster vormen.

Arrays maken gebruik van deze “raster”-structuur om lijsten met gerelateerde informatie op te slaan op aangrenzende geheugenlocaties, zodat het vinden van die waarden uiterst efficiënt verloopt. 🔳🔳🔳🔳 🔳

U kunt arrays als volgt beschouwen:

De elementen ervan staan naast elkaar in het geheugen. Als je er meer dan één moet benaderen, wordt het proces extreem geoptimaliseerd omdat je computer al weet waar de waarde zich bevindt.

Overheerlijkend, toch? Laten we eens leren hoe dit achter de schermen werkt! 😃

📚 Classificatie

Arrays worden geclassificeerd als Homogene Data Structuren omdat ze elementen van hetzelfde type opslaan.

Ze kunnen getallen, strings, booleaanse waarden (waar en onwaar), tekens, objecten, enzovoort opslaan. Maar als je eenmaal het type van de waarden die je array zal opslaan hebt gedefinieerd, moeten alle elementen van datzelfde type zijn. Je kunt geen verschillende gegevenstypen “mengen”.

👀 Lezen van waarden – De magie begint!

De verbazingwekkende kracht van arrays komt voort uit hun efficiëntie om waarden te benaderen. Dit wordt bereikt dankzij de rasterachtige structuur. Laten we dit eens in meer detail bekijken.🔍

Wanneer u een array maakt, dan:
– Wijst u het toe aan een variabele. 👈
– Het type elementen definiëren dat het zal opslaan. 🎈
– De grootte ervan bepalen (het maximum aantal elementen). 📚

💡 Opmerking: De naam die u aan deze variabele toekent is zeer belangrijk omdat u deze later in uw code zult gebruiken om toegang te krijgen tot waarden en om de array te wijzigen.

Maar hoe kunt u de computer vertellen tot welke specifieke waarde u toegang wenst te krijgen? Hier spelen indices een cruciale rol!

1️⃣ Indices

Je gebruikt een zogenaamde “index” (“indices” in het meervoud) om toegang te krijgen tot een waarde in een array. Dit is een getal dat verwijst naar de plaats waar de waarde is opgeslagen.

Zoals u in het diagram hieronder kunt zien, wordt naar het eerste element in de array verwezen met index 0. Naarmate u verder naar rechts gaat, neemt de index met één toe voor elke plaats in het geheugen.

💡 Opmerking: Ik weet dat het op het eerste gezicht vreemd lijkt om bij 0 te beginnen tellen in plaats van bij 1, maar dit wordt Nul-gebaseerde Nummering genoemd. Het is heel gebruikelijk in de informatica.

De algemene syntaxis om een element te benaderen is: <ArrayVariable>

Voorbeeld:
Als uw array is opgeslagen in de variabele myArray en u wilt toegang tot het eerste element (op index 0), dan zou u myArray

2️⃣ Geheugen

Nu u weet hoe u toegang krijgt tot waarden, laten we eens kijken hoe arrays worden opgeslagen in het geheugen van uw computer. Wanneer u de grootte van de array definieert, wordt al die ruimte in het geheugen vanaf dat moment “gereserveerd” voor toekomstige waarden die u misschien wilt invoegen.

💡 Opmerking: Als u de array niet met waarden vult, wordt die ruimte gereserveerd en leeg gehouden totdat u dat wel doet.

Voorbeeld:
Laten we zeggen dat u een array van grootte 5 definieert maar slechts één waarde invoegt. Al die resterende ruimte is leeg en “gereserveerd” in het geheugen, wachtend op toekomstige toewijzingen.

Dit is belangrijk omdat arrays uiterst efficiënt zijn in het benaderen van waarden, omdat alle elementen worden opgeslagen in aaneengesloten ruimten in het geheugen. Op deze manier weet de computer precies waar hij moet zoeken om de door u gevraagde informatie te vinden.

Maar… er zit ook een keerzijde aan 😞 want dit is niet geheugenefficiënt. U reserveert geheugen voor toekomstige bewerkingen die misschien niet zullen plaatsvinden. Daarom worden arrays aanbevolen in situaties waarin je van tevoren weet hoeveel elementen je gaat opslaan.

🔧 Operations – Behind the Scenes!

Nu je weet wat arrays zijn wanneer ze gebruikt worden, en hoe ze elementen opslaan, duiken we in hun operaties zoals invoegen en verwijderen.

1️⃣ Invoegen – Welkom!

Laten we zeggen dat we een array van grootte 6 hebben en dat er nog een lege ruimte is. We willen een element “e” invoegen aan het begin van de array (index 0), maar deze plaats is al ingenomen door het element “a.” Wat moeten we doen?

Om in arrays in te voegen, verplaatsen we alle elementen die zich rechts van de invoegplaats bevinden, één index naar rechts. Element “a” staat nu op index 1, element “b” op index 2 enzovoort…

💡 Opmerking: U moet een variabele maken om de laatste index bij te houden die elementen bevat. In het bovenstaande diagram is de array gevuld tot index 4 voor de insertie. Op deze manier kun je bepalen of de array vol is en welke index je moet gebruiken om een element aan het eind in te voegen.

Na dit gedaan te hebben, is ons element succesvol ingevoegd. 👏

⚠️ Wacht eens even! Wat gebeurt er als de matrix vol is?

Wat denk je dat er gebeurt als de matrix vol is en je probeert een element in te voegen? 😱

In dat geval moet u een nieuwe, grotere matrix maken en alle elementen handmatig naar deze nieuwe matrix kopiëren. Deze bewerking kost veel tijd. Stel je voor wat er zou gebeuren als je een matrix met miljoenen elementen had! Dat zou heel lang kunnen duren. ⏳

💡 Opmerking: De enige uitzondering op deze regel, wanneer het invoegen zeer snel gaat, is wanneer u een element aan het eind van de array invoegt (op de index die zich rechts van het laatste element bevindt) en er nog ruimte beschikbaar is. Dit gebeurt in constante tijd O(1).

2️⃣ Deletion- Bye, Bye!

Nu zeggen we dat je een element uit de array wilt verwijderen.

Om de efficiëntie van random access te behouden (het extreem snel kunnen benaderen van de array via een index) moeten de elementen in aaneengesloten ruimtes van het geheugen worden opgeslagen. Je kunt niet zomaar een element verwijderen en die ruimte leeg laten.

Je moet de elementen die komen na het element dat je wilt verwijderen één index naar links verplaatsen.

En uiteindelijk heb je deze resulterende array 👇. Zoals u kunt zien, is “b” met succes verwijderd.

💡 Opmerking: Verwijderen is zeer efficiënt wanneer u het laatste element verwijdert. Omdat je een variabele moet maken om de laatste index bij te houden die elementen bevat (in het diagram hierboven, index 3), kun je dat element direct verwijderen met behulp van de index.

3️⃣ Een element vinden

U hebt drie mogelijkheden om een element in een array te vinden:

• Als u weet waar het zich bevindt, gebruikt u de index.
• Als u niet weet waar het zich bevindt en uw gegevens zijn gesorteerd, kunt u algoritmen gebruiken om uw zoekopdracht te optimaliseren, zoals Binary Search.
• Als u niet weet waar het zich bevindt en uw gegevens zijn niet gesorteerd, moet u elk element in de array doorzoeken en controleren of het huidige element het element is dat u zoekt (zie de onderstaande reeks diagrammen).

👋 Samengevat…

• Arrays zijn uiterst krachtige datastructuren waarin elementen van hetzelfde type worden opgeslagen. Het type elementen en de grootte van de array liggen vast en worden gedefinieerd wanneer u de array maakt.
• Onmiddellijk nadat de array is gemaakt, wordt geheugen gealloceerd en het blijft leeg totdat u de waarden toewijst.
• De elementen bevinden zich op aaneengesloten plaatsen in het geheugen, zodat ze zeer efficiënt kunnen worden benaderd (willekeurige toegang, O(1) = constante tijd) met behulp van indices.
• Indices beginnen bij 0, niet bij 1 zoals we gewend zijn.
• Het invoegen van elementen aan het begin of in het midden van de array houdt in dat elementen naar rechts worden verplaatst. Als de array vol is, wordt een nieuwe, grotere array gemaakt (wat niet erg efficiënt is). Invoegen aan het eind van de array is zeer efficiënt, constante tijd O(1).
• Het verwijderen van elementen aan het begin of in het midden van de array houdt in dat alle elementen naar links worden verplaatst om te voorkomen dat er een lege ruimte in het geheugen overblijft. Dit garandeert dat de elementen worden opgeslagen in aaneengesloten ruimten in het geheugen. Verwijderen aan het eind van de array is erg efficiënt omdat je alleen het laatste element verwijdert.
• Om een element te vinden, moet je de hele array doorzoeken tot je het vindt. Als de gegevens gesorteerd zijn, kun je algoritmen zoals Binary Search gebruiken om het proces te optimaliseren.

“Leer van gisteren, leef voor vandaag, hoop voor morgen. Het belangrijkste is om niet te stoppen met vragen stellen.”
– Albert Einstein

👋 Dank je wel!

Ik hoop echt dat je mijn artikel leuk vond. ❤️
Volg me op Twitter om meer artikelen zoals deze te vinden. 😃