Inhoud

• Vergelijkingstabel
• Definitie van Array
• Laten we eens kijken naar enkele van de concepten die moeten worden onthouden over arrays:
• Bewerkingen die worden uitgevoerd op arrays zijn:
• Voorbeeld
• Definitie van gekoppelde lijst
• Bewerkingen uitgevoerd op gekoppelde lijst zijn:
• Voorbeeld
• Gevolgtrekking

Het grote verschil tussen reeks en Gekoppelde lijst met betrekking tot hun structuur. Arrays zijn index gebaseerd gegevensstructuur waarbij elk element is gekoppeld aan een index. Aan de andere kant vertrouwt Linked lijst referenties waarbij elk knooppunt bestaat uit de gegevens en de verwijzingen naar het vorige en volgende element.

Kort gezegd is een array een set vergelijkbare gegevensobjecten die zijn opgeslagen in opeenvolgende geheugenlocaties onder een gemeenschappelijke titel of een variabelenaam.

Terwijl een gekoppelde lijst een gegevensstructuur is die een reeks elementen bevat waarbij elk element is gekoppeld aan het volgende element. Er zijn twee velden in een element van een gekoppelde lijst. Een daarvan is het gegevensveld en de andere is het linkveld. Het gegevensveld bevat de werkelijke waarde die moet worden opgeslagen en verwerkt. Verder bevat het koppelingsveld het adres van het volgende gegevensitem in de gekoppelde lijst. Het adres dat wordt gebruikt om toegang te krijgen tot een bepaald knooppunt staat bekend als een pointer.

Een ander belangrijk verschil tussen een array en een gelinkte lijst is dat Array een vaste grootte heeft en vooraf moet worden aangegeven, maar de gelinkte lijst is niet beperkt tot de grootte en uitbreiding en contract tijdens de uitvoering.

1. Vergelijkingstabel
2. Definitie
3. Belangrijkste verschillen
4. Gevolgtrekking

Vergelijkingstabel

Basis voor vergelijking	reeks	Gekoppelde lijst
basis-	Het is een consistente set van een vast aantal gegevensitems.	Het is een geordende set met een variabel aantal gegevensitems.
Grootte	Opgegeven tijdens aangifte.	Geen behoefte om te specificeren; groeien en krimpen tijdens de uitvoering.
Opslagtoewijzing	Elementlocatie wordt toegewezen tijdens het compileren.	Elementpositie wordt toegewezen tijdens uitvoering.
Volgorde van de elementen	Achtereenvolgens opgeslagen	Willekeurig opgeslagen
Toegang tot het element	Direct of willekeurig toegankelijk, d.w.z. Geef de array-index of het subscript op.	Achtereenvolgens benaderd, d.w.z. Traverse vanaf de eerste knoop in de lijst door de aanwijzer.
Element invoegen en verwijderen	Langzaam relatief als schakelen vereist is.	Makkelijker, snel en efficiënt.
Zoeken	Binair zoeken en lineair zoeken	lineair zoeken
Geheugen vereist	minder	Meer
Geheugengebruik	Niet effectief	doeltreffend

Definitie van Array

Een array wordt gedefinieerd als een set van een bepaald aantal homogene elementen of gegevensitems. Het betekent dat een array slechts één gegevenstype kan bevatten, ofwel alle gehele getallen, alle getallen met drijvende komma of alle tekens. Verklaring van een array is als volgt:
int een;
Waar int het gegevenstype of de type-elementenreeks opgeeft. "A" is de naam van een array en het getal dat tussen vierkante haakjes staat, is het aantal elementen dat een array kan opslaan, dit wordt ook de grootte of lengte van de array genoemd.

Laten we eens kijken naar enkele van de concepten die moeten worden onthouden over arrays:

• De afzonderlijke elementen van een array kunnen worden geopend door de naam van de array te beschrijven, gevolgd door een index of subscript (de locatie van het element in de array bepalen) tussen vierkante haken. Om bijvoorbeeld het 5e element van de array op te halen, moeten we een instructie a schrijven.
• In elk geval worden de elementen van een array opgeslagen in een opeenvolgende geheugenlocatie.
• Het allereerste element van de array heeft index nul. Dit betekent dat het eerste en laatste element worden gespecificeerd als respectievelijk een en een.
• Het aantal elementen dat in een array kan worden opgeslagen, d.w.z. de grootte van een array of de lengte ervan wordt gegeven door de volgende vergelijking:
  (bovengrens-ondergrens) + 1
  Voor de bovenstaande array zou het (9-0) + 1 = 10 zijn. Waar 0 de ondergrens van de matrix is ​​en 9 de bovengrens van de matrix.
• Arrays kunnen door de lus worden gelezen of geschreven. Als we de eendimensionale array lezen, vereist deze één lus voor het lezen en een andere voor het schrijven (en) van de array, bijvoorbeeld:
  een. Voor het lezen van een array
  voor (i = 0; i <= 9; i ++)
  {scanf ("% d", & a); }
  b. Voor het schrijven van een array
  voor (i = 0; i <= 9; i ++)
  {f ("% d", a); }
• In het geval van een 2-D array zou het twee lussen vereisen en op dezelfde manier zou n-dimensionale array n lussen nodig hebben.

Bewerkingen die worden uitgevoerd op arrays zijn:

1. Creatie van array
2. Een array doorlopen
3. Nieuwe elementen invoegen
4. Verwijderen van vereiste elementen.
5. Wijziging van een element.
6. Arrays samenvoegen

Voorbeeld

Het volgende programma illustreert het lezen en schrijven van de array.

#include
#include
void main ()
{
int a, i;
f ("Voer de array in");
voor (i = 0; i <= 9; i ++)
{
scanf ("% d", & a);
}
f ("Voer de array in");
voor (i = 0; i <= 9; i ++)
{
f ("% d n", a);
}
getch ();
}

Definitie van gekoppelde lijst

Gekoppelde lijst is een specifieke lijst van enkele gegevenselementen die aan elkaar zijn gekoppeld. Hierin verwijst elk element naar het volgende element dat de logische volgorde weergeeft. Elk element wordt een knooppunt genoemd, dat uit twee delen bestaat.

INFO-gedeelte dat de informatie opslaat en POINTER die naar het volgende element verwijst. Zoals u weet voor het opslaan van adressen, hebben we een unieke datastructuur in C genaamd pointers. Daarom moet het tweede veld van de lijst van het type aanwijzer zijn.

Typen gekoppelde lijsten zijn Enkel gekoppelde lijst, Dubbel gekoppelde lijst, Circulaire gekoppelde lijst, Circulaire dubbel gekoppelde lijst.

Bewerkingen uitgevoerd op gekoppelde lijst zijn:

1. schepping
2. doorkruisen
3. Invoeging
4. verwijdering
5. Zoeken
6. Aaneenschakeling
7. tonen

Voorbeeld

Het volgende fragment illustreert het maken van een gekoppelde lijst:

struct knooppunt
{
int num;
stop knooppunt * vervolgens;
}
start = NULL;
void create ()
{
typedef struct knooppunt NODE;
NODE * p, * q;
char keuze;
eerste = NULL;
Doen
{
p = (NODE *) malloc (sizeof (NODE));
f ("Voer het gegevensitem in n");
scanf ("% d", & p -> num);
if (p == NULL)
{
q = start;
terwijl (q -> volgende! = NULL)
{q = q -> volgende
}
p -> volgende = q -> volgende;
q -> = p;
}
anders
{
p -> volgende = start;
start = p;
}
f ("Wilt u doorgaan (typ y of n)? n");
scanf ("% c", & keuze);
}
terwijl ((keuze == y) || (keuze == Y));
}

1. Een array is dat de gegevensstructuur een verzameling gegevenselementen van hetzelfde type bevat, terwijl de gekoppelde lijst als niet-primitieve gegevensstructuur wordt beschouwd een verzameling ongeordende gekoppelde elementen bevat die knooppunten worden genoemd.
2. In de array behoren de elementen tot indexen, d.w.z. als u in het vierde element wilt komen, moet u de variabelenaam schrijven met de index of locatie binnen de vierkante haakjes.
   In een gekoppelde lijst moet je echter vanuit het hoofd beginnen en je een weg banen totdat je bij het vierde element komt.
3. Hoewel de toegang tot een elementarray snel is, terwijl de gekoppelde lijst lineaire tijd kost, dus het is nogal langzamer.
4. Bewerkingen zoals invoegen en verwijderen in arrays kosten veel tijd. Aan de andere kant is de uitvoering van deze bewerkingen in gekoppelde lijsten snel.
5. Arrays hebben een vaste grootte. Gekoppelde lijsten zijn daarentegen dynamisch en flexibel en kunnen worden uitgebreid en kleiner worden.
6. In een array wordt geheugen toegewezen tijdens het compileren, terwijl het in een gekoppelde lijst wordt toegewezen tijdens uitvoering of runtime.
7. Elementen worden opeenvolgend in arrays opgeslagen, terwijl het willekeurig in gekoppelde lijsten wordt opgeslagen.
8. De vereiste geheugen is minder vanwege het feit dat feitelijke gegevens worden opgeslagen in de index in de array. Daarentegen is er behoefte aan meer geheugen in gekoppelde lijsten vanwege de opslag van extra volgende en vorige referentie-elementen.
9. Bovendien is geheugengebruik inefficiënt in de array. Omgekeerd is geheugengebruik efficiënt in de array.

Gevolgtrekking

Matrix- en gekoppelde lijsten zijn de typen gegevensstructuren die verschillen in hun structuur, toegangs- en manipulatiemethoden, geheugenvereiste en gebruik. En hebben een bijzonder voordeel en nadeel ten opzichte van de implementatie ervan. Bijgevolg kan een van beide worden gebruikt als per behoefte.