De klasse TList is ontworpen om een ​​lijst met verwijzingen op te slaan naar structuren die zich in de adresruimte bevinden (objecten, dynamische arrays, variabelen). Net als de TstringList biedt de pointerlijst effectief werk met lijstelementen.

TLijst klasse

De kern van de klasse TList is een lijst met verwijzingen. De lijst zelf is een dynamische reeks verwijzingen die toegankelijk zijn via een geïndexeerde eigenschap
eigenschap Items: aanwijzer;
De nummering van elementen begint vanaf nul.
Via de eigenschap is directe toegang tot array-elementen mogelijk
type
PPointerLijst = ^TPointerLijst;
TPointerList = reeks aanwijzers;
eigenschappenlijst: PPointerList;
die een alleen-lezen attribuut heeft.
Omdat lijstelementen verwijzingen zijn naar bepaalde structuren, hebben ze rechtstreeks toegang componenten van deze structuren via de eigenschap items is niet mogelijk.

Hoe dit gedaan kan worden, wordt in onderstaand voorbeeld beschreven.

Opmerking
De lijst kan verwijzingen naar heterogene structuren bevatten. Het is niet nodig om alleen verwijzingen naar objecten of verwijzingen naar records in een lijst op te slaan.
De lijstbewerkingen die in de klasse TList zijn geïmplementeerd, voldoen aan de behoeften van de ontwikkelaar en vallen samen met de bewerkingen van een lijst met tekenreeksen.
Gebruik de methode om een ​​nieuwe aanwijzer aan het einde van de lijst toe te voegen
functie Add(Item: Pointer): Geheel getal;
Het rechtstreeks toekennen van een waarde aan een element dat nog niet is aangemaakt met behulp van de Add-methode zal een runtimefout veroorzaken.
Op de gewenste locatie in de lijst kan een nieuwe index worden toegevoegd. Hiervoor wordt de methode gebruikt
procedure Invoegen(Index: geheel getal; Item: aanwijzer);
De indexparameter specificeert het vereiste volgnummer in de lijst.
Het overbrengen van een bestaand element naar een nieuwe locatie gebeurt met behulp van de methode
procedure Move(Curindex, Nieuwe index: geheel getal);
De CurIndex-parameter specificeert de oude pointerpositie. De parameter NewIndex specificeert de nieuwe positie.
U kunt ook twee elementen omwisselen die zijn gedefinieerd door de Indexl- en Index2-parameters:
procedure Uitwisseling(Indexl, Index2: Geheel getal);
Er zijn twee methoden die worden gebruikt om verwijzingen uit een lijst te verwijderen. Als de index bekend is, wordt de methode gebruikt
procedure Verwijderen(Index: Geheel getal);
Als de pointer zelf bekend is, wordt de methode gebruikt
Deze methoden verminderen de hoeveelheid geheugen die aan de lijst is toegewezen niet. Als u dit moet doen, moet u de capaciteitseigenschap gebruiken. Er is ook een Expand-methode die het toegewezen geheugen automatisch vergroot, afhankelijk van de huidige grootte van de lijst.
functie Uitbreiden: TLijst;
Om de methode te laten werken, is het noodzakelijk dat aantal = Capaciteit.
Methode
procedure Duidelijk; dynamisch;
gebruikt om alle elementen van een lijst in één keer te verwijderen. Gebruik de methode om naar een aanwijzer op basis van zijn waarde te zoeken
functie IndexOf(Item: Aanwijzer): Integer;
De methode retourneert de index van het gevonden element in de lijst. Als de zoekopdracht niet succesvol is, retourneert deze - 1.
Gebruik de methode om lijstelementen te sorteren

procedure Sort(Vergelijk: TListSortVergelijk);
Omdat de samenstelling van de structuur waarnaar een lijstelement verwijst niet op voorhand kan worden gegeneraliseerd, wordt de ontwikkeling van een procedure die sortering uitvoert aan de programmeur toevertrouwd. De Sort-methode biedt alleen een paarsgewijze vergelijking van pointers op basis van een algoritme dat door de programmeur is gemaakt (voor een voorbeeld van sorteren, zie hierboven in de sectie "TStringList Class").
Alle eigenschappen en methoden van de klasse TList worden weergegeven in Tabel. 7.2.
Tabel 7.2. Eigenschappen en methoden van de klasse TList
Aankondiging

Beschrijving
eigenschap Capaciteit: geheel getal;
Bepaalt het aantal rijen waarvoor geheugen wordt toegewezen
eigenschap Aantal: geheel getal;
Retourneert het aantal rijen in een lijst
eigenschap Items: aanwijzer;
Lijst met aanwijzingen
type
TPointerList = reeks aanwijzers;
PPointerLijst = ATPointerLijst; eigenschappenlijst: PPointerList;
Dynamische array aanwijzingen
functie Add(Item: Pointer): Geheel getal;
Voegt een nieuwe aanwijzer toe aan de lijst
procedure Duidelijk; dynamisch;
Wist de lijst volledig
procedure Verwijderen (Index: Geheel getal:;
Verwijdert een aanwijzer met een index
Index
klasseprocedure Fout (const Ksg: string; Data: Integer); virtueel;
Genereert uitzonderlijk
EListError-situatie.
Het foutbericht wordt gegenereerd op basis van de Msg-formaattekenreeks en de numerieke Data-parameter
procedure Uitwisseling(Indexl, Index2: Geheel getal);
Wisselt pointers uit met Indexl en Index2
functie Uitbreiden: TLijst;
Vergroot de hoeveelheid geheugen die aan de lijst is toegewezen
functie Eerste: aanwijzer;
Retourneert de eerste aanwijzer uit een lijst
functie IndexOf(Item: Aanwijzer): Integer;
Geeft de index van de aanwijzer terug, gespecificeerd per parameter Item
procedure Invoegen (Index: geheel getal; Item: aanwijzer) ;
Inzetstukken nieuw onderdeel Positie van artikelen Index
functie Laatste: Wijzer;
Retourneert de laatste aanwijzer in de lijst
procedure Move(Curindex, Nieuwe index: geheel getal);
Verplaatst een lijstitem naar een nieuwe locatie
procedurepakket;
Verwijdert alle null-aanwijzers (nul) uit een lijst
functie Verwijderen (Item: Aanwijzer): Integer;
Verwijdert een aanwijzer uit de lijst
Item
type TListSortCompare = functie (Iteml, Item2: Pointer): geheel getal;
procedure Sort(Vergelijk: TListSortVergelijk);
Sorteert lijstitems

Voorbeeld van het gebruik van een lijst met verwijzingen

Laten we eens kijken naar het gebruik van lijsten met verwijzingen aan de hand van het voorbeeld van de DemoList-toepassing.
Wanneer u op het aanvraagformulier klikt, wordt een punt weergegeven en wordt een serienummer toegewezen. Tegelijkertijd worden de coördinaten en het puntnummer naar de overeenkomstige eigenschappen van het gemaakte exemplaar van de TMypixel-klasse geschreven. Een verwijzing naar dit object wordt doorgegeven aan de nieuwe pixList.
Als gevolg hiervan kan na het wissen van het formulier de gehele reeks punten worden hersteld met behulp van verwijzingen naar objecten uit de lijst.

De lijst met punten kan in oplopende volgorde worden gesorteerd op X-coördinaat.

Lijst. Module van de hoofdvorm van het DemoList-project
Eenheid Hoofd;
interface
gebruikt
Windows, Berichten, SysUtils, Klassen, Afbeeldingen, Besturingselementen, Formulieren,
type
Dialoogvensters, StdCtrls, knoppen;
TMainForm = klasse(TForm)
LijstBtn: TBitBtn;
ClearBtn: TBitBtn;
DelBtn: TBitBtn;
SortBtn: TBitBtn;
procedure FormCreate(Afzender: TObject);
procedure FormClose(Sender: TObject; var Action: TSluitAction);

procedure FormMouseDown(Afzender: TObject; Knop: TMouseButton;
procedure LijstBtnClick(Afzender: TObject);
procedure ClearBtnClick(Afzender: TObject);
procedure DelBtnClick(Afzender: TObject);
procedure SortBtnClick(Afzender: TObject);
privé
PixLijst: TLijst;
PixNum: geheel getal; publiek
(Openbare verklaringen)
einde;
TMijnPixel = klasse(TObject)
fx:geheel getal;
FY: geheel getal;
FText: geheel getal;
constructor Create(X, Y, Num: geheel getal);
(Openbare verklaringen)
procedure SetPixel;
var
Hoofdformulier: TMainForm;
uitvoering
($R *.DFM)
const PixColor = clRed;
var CurPixel: TMyPixel;
constructor TMyPixel.Create(X, Y, Num: geheel getal);
beginnen
geërfd Creëren;
FX:=X;
FJ:= J;
FText:= Aantal;
(Openbare verklaringen)
SetPixel;
constructor TMyPixel.Create(X, Y, Num: geheel getal);
procedure TMyPixel.SetPixel;
MainForm.Canvas.PolyLine();
(Openbare verklaringen)
MainForm.Canvas.TextOut(FX +1, FY + 1, IntToStr(FText));
functie PixCompare(Iteml, Item2: Pointer): Integer;
constructor TMyPixel.Create(X, Y, Num: geheel getal);
var Pixl, Pix2: TMyPixel;
Pixl:= Artikel;
Pix2:= Artikel2;
(Openbare verklaringen)
Resultaat:= Pixl.FX - Pix2.FX;
constructor TMyPixel.Create(X, Y, Num: geheel getal);
procedure TMainForm.FormCreate(Afzender: TObject);
PixList:= TList.Create;
PixNum:= 1; (Puntenteller)
Canvas.Pen.Color:= PixColor; (Puntkleur)
Canvas.Pen.Breedte:= 3; (Puntgrootte)
(Openbare verklaringen)
Canvas.Borstel.Kleur:= Kleur; (Tekstachtergrondkleur is gelijk aan formulierkleur)
constructor TMyPixel.Create(X, Y, Num: geheel getal);
procedure TMainForm.FormClose(Sender: TObject; var Action: TSluitAction);
(Openbare verklaringen)
PixList.Gratis;
Verschuiving: TShiftState; X, Y: geheel getal);
constructor TMyPixel.Create(X, Y, Num: geheel getal);
PixList.Add(TMyPixel.Create(X, Y, PixNum));
Inc(PixNum);
(Openbare verklaringen)
procedure TMainForm.ListBtnClick(Afzender: TObject);
var i: geheel getal;
constructor TMyPixel.Create(X, Y, Num: geheel getal);
met PixList doen
voor i:= 0 tot tellen - 1 doen
constructor TMyPixel.Create(X, Y, Num: geheel getal);
CurPixel:= Artikelen[i]; CurPixel.SetPixel;
einde; einde;
procedure TMainForm.ClearBtnClick(Afzender: TObject);
constructor TMyPixel.Create(X, Y, Num: geheel getal);
Canvas.FillRect(Rect(0, 0, Breedte, Hoogte));
(Openbare verklaringen)
procedure TMainForm.DelBtnClick(Afzender: TObject);
constructor TMyPixel.Create(X, Y, Num: geheel getal);
PixList.Clear;
PixNum:= 1;
(Openbare verklaringen)
procedure TMainForm.SortBtnClick(Afzender: TObject);
var i: geheel getal;
constructor TMyPixel.Create(X, Y, Num: geheel getal);
PixList.Sort(PixVergelijken);
met PixList doen
for i:= 0 tot Count - 1 do TMyPixel(Items[i]).FText:= i + 1;
(Openbare verklaringen)
einde.
De klasse TMyPixel biedt opslag van de coördinaten van een punt en het serienummer ervan in de reeks. Deze parameters worden doorgegeven aan de klassenconstructor. De setPixel-methode zorgt ervoor dat er een punt op de formulieromtrek wordt getekend.
Voor elke klasse wordt een exemplaar van de klasse gemaakt nieuw punt wanneer op de muisknop wordt geklikt in de FormMouseDown-handlermethode. Hier is een verwijzing naar nieuw voorwerp opgeslagen in het PixList-lijstelement gemaakt met de Add-methode.
Het programma “onthoudt” dus de locatie en volgorde van de punten.
De ListBtnClick-handlermethode zorgt ervoor dat de punten worden weergegeven. Om dit te doen, wordt de huidige lijstaanwijzer in een lus overgebracht naar een variabele van het objecttype curPixel, dat wil zeggen dat deze variabele op zijn beurt wordt "bezocht" door alle gemaakte objecten, waarvan de verwijzingen in de lijst zijn opgeslagen.
Dit wordt gedaan om toegang te krijgen tot de eigenschappen van objecten (dit kan niet rechtstreeks via een pointer). Het tweede type castingmethode wordt besproken in de SortBtnClick-handlermethode.
Voordat de punten opnieuw worden weergegeven, moet het oppervlak van het formulier worden gereinigd.
Deze bewerking wordt uitgevoerd door de clearBtnClick-handlermethode. De lijst met punten kan in oplopende volgorde worden gesorteerd op X-coördinaat. Om dit te doen, wordt de Sort-methode van PixList aangeroepen in de SortBtnClick-handlermethode. De methodeparameter (variabele van het procedurele type) geeft de PixCompare-functie door, die een mechanisme biedt dat is ingekapseld in de Sort-methode voor het opsommen van lijstelementen met een algoritme om de prioriteit van twee aangrenzende elementen te bepalen. Als de functie terugkeert positief getal
In ons geval werden de X-coördinaten van twee punten vergeleken. Als gevolg van deze oplopende sortering zijn de objecten zo gerangschikt dat het eerste element van de lijst naar het object met de minimale X-coördinaat wijst, en het laatste element naar het object met de maximale X-coördinaat wijst.
Na het sorteren hoeft u alleen nog maar alle punten opnieuw te nummeren. Hierdoor ontstaat er een lus in de SortBtnclick-handlermethode. Let op het type casting dat in dit geval wordt gebruikt en dat toegang biedt tot de eigenschappen van instanties van de TMypixel-klasse.
De DeiBtnClick-handlermethode biedt volledige reiniging lijst pixLijst.

Invoering

1. Definitie van ADT

2. Algemene bepalingen

3. Beschrijving van de activiteiten

3.1 Elementbewerking toevoegen

3.2 De werking van het toevoegen van een element na het opgegeven element

3.3 Verwijderbewerking gespecificeerd element

3.4 Lijstinvoer afdrukken

4. Implementatie van ADT-lijst

4.1 Hoofdfunctie

4.2 Interface

4.3 Implementatie van methoden

Conclusie

Referenties

Bijlage A: Algoritmegrafieken

Invoering

Ongeacht het soort probleem dat wordt opgelost, werkt elk programma met een bepaald soort gegevens, en het programma zelf vertegenwoordigt methoden voor het beheren en verwerken van deze gegevens. De snelheid waarmee een programma een bepaalde taak voltooit, hangt niet alleen af ​​van de algoritmen die het gebruikt om gegevens te verwerken en te beheren, maar ook van de organisatie van de gegevens zelf. Zo komen we bij het concept van datastructuren.

Directe interactie tussen het programma via de gebruiker en datastructuren laat veel gegevens open, waarvan wijziging op een onwettige manier (het omzeilen van de interface) tot ongewenste gevolgen kan leiden. Om voorbij te komen dit probleem het is noodzakelijk om “muren te bouwen” tussen de gegevens en het programma, waardoor er alleen een “venster” overblijft in de vorm van een interface. Om dit te doen, is het noodzakelijk om de abstracte gegevenstypen te definiëren waarmee deze muren worden opgetrokken.

In dit werk wordt een abstract datatype (ADT) ontwikkeld: een lijst, die vervolgens wordt geïmplementeerd als een gekoppelde lijst, geïmplementeerd met behulp van pointer-gebaseerde indirectie. De ontwikkeling van ADT wordt in meer detail besproken in.

1. Definitie van ADT

Data-abstractie beschrijft wat er met een dataset kan worden gedaan, waarbij de vraag "hoe wordt het gedaan?" wordt genegeerd. Data-abstractie is een manier om te ontwikkelen individuele componenten programma, ongeacht de rest van het onderdeel (andere componenten). Data-abstractie is dus een natuurlijke uitbreiding van functionele abstractie, waardoor functies relatief geïsoleerd van elkaar kunnen worden ontwikkeld. Een set gegevens gecombineerd met een reeks bewerkingen daarop wordt een abstract gegevenstype genoemd. De beschrijving van de in de ADT opgenomen handelingen moet strikt genoeg zijn om de impact ervan op de gegevens accuraat weer te geven. Maar het mag niet specificeren hoe gegevens worden opgeslagen of details over hoe bewerkingen worden uitgevoerd. Specifieke methode gegevensopslag (gegevensstructuur) wordt alleen geselecteerd bij de implementatie van een ADT. Datastructuur is een constructie die in een programmeertaal is gedefinieerd voor het opslaan van een reeks gegevens. Afhankelijk van de toewijzingsoptie worden de volgende gegevens gedefinieerd:

1. Naam van de chip

2. Kosten

3. Hoeveelheid

De volgende bewerkingen zijn erop gedefinieerd:

1.Een element toevoegen aan een ongeordende lijst

2. Een element met een bepaald veld verwijderen uit een ongeordende lijst

3. Een element toevoegen na het opgegeven element

4.Alle elementen met een bepaald veld verwijderen

5. Druk de lijst af

Dit setje definieert de reeks toegestane bewerkingen op de gegevens die in de taak zijn gedefinieerd, d.w.z. we krijgen een abstract gegevenstype.

2. Algemene bepalingen

Een abstracte lijst kan als een array worden geïmplementeerd - op het eerste gezicht een voor de hand liggende stap. De array heeft vaste maat(in de meeste programmeertalen), terwijl de lengte van een abstracte lijst onbeperkt is. De datastructuur wordt dus statisch, wat een nadeel is.

Een andere aanzienlijk nadeel is een voortzetting van het voordeel van arrays - de sequentiële rangschikking van gegevens in aangrenzende cellen, met andere woorden, die zo vaak wordt geproduceerd en daarom vereist maximale snelheid Bij de uitvoering leiden bewerkingen zoals het invoegen en verwijderen van een element tot de noodzaak om array-elementen te verschuiven, wat uitgaven oplevert extra tijd.

Het principe van het implementeren van een lijst die geen gebruik maakt van elementverschuiving is gebaseerd op indirecte adressering. Andere manieren om abstracte lijsten te implementeren worden in detail beschreven in.

Elk knooppunt gekoppelde lijst bestaat uit twee delen: de gegevens zelf en een verwijzing naar het volgende element - hetzelfde knooppunt of een NULL-constante.

Omdat volgens het principe van inkapseling gegevens alleen toegankelijk mogen zijn via methoden die voor dit doel zijn gedefinieerd, wordt voor de gegevens de private toegangsspecificatie gedefinieerd.

Het mechanisme voor het toewijzen van geheugen voor elementen van een op aanwijzers gebaseerde lijst omvat dynamische selectie geheugen gebruikt exploitanten nieuw en verwijderen. Bij het maken van een nieuw element is het dus logisch om alleen geheugen toe te wijzen aan nieuwe gegevens, en niet aan reeds bepaalde methoden– Lijstbewerkingen. Daarom is het noodzakelijk om methoden uit de datastructuur te verwijderen. In dit werk werd een techniek gebruikt om de interface uit te breiden door een methodestructuur te creëren: een vriendelijke klasse waarvan de methoden toegang hebben tot privéleden van de knooppuntklasse.

U kunt meer leren over de principes van objectgeoriënteerd programmeren op.

Verwijzingen naar de kop en de staart van een lijst worden gedeclareerd in de klasse List omdat ze essentieel noodzakelijk zijn voor het implementeren van ADT-methoden, terwijl ze voor de datastructuur zelf geen enkele betekenis hebben.

Methoden die gegevens op geen enkele manier mogen wijzigen, worden gedeclareerd met behulp van trefwoord const.

Voer alle acties uit zoals bij gewone variabelen. Om mee te werken dynamische distributie geheugen is erg handig in gebruik gerelateerde structuren gegevens, zoals afzonderlijk gekoppelde lijsten. Het eenvoudigste voorbeeld van een lijst is een array waarin alle elementen opeenvolgend zijn gerangschikt. Maar deze weergave heeft een belangrijk nadeel: het is noodzakelijk om het aantal elementen vooraf nauwkeurig te specificeren...

Ontwikkelingsaanpak efficiënt algoritme Om elk probleem op te lossen, moet je de essentie ervan bestuderen. Heel vaak kan het probleem worden geformuleerd in de taal van de verzamelingenleer, die tot de fundamentele takken van de wiskunde behoort. In dit geval kan het algoritme voor het oplossen ervan worden uitgedrukt in termen van basisbewerkingen op sets. Dergelijke taken omvatten ook taken ophalen van informatie waar problemen worden opgelost...

Gegevens worden zinvoller als ze op de een of andere manier worden gesorteerd. Vaak moet u gegevens op meerdere sorteren op verschillende manieren. Ten tweede zijn veel sorteeralgoritmen dat wel interessante voorbeelden programmering. Ze demonstreren belangrijke technieken zoals gedeeltelijke ordening, recursie, het samenvoegen van lijsten en het opslaan van binaire bomen in een array. Eindelijk, sorteren...

Stroom (processors vervangen), capaciteit uitbreiden RAM, toevoegen externe apparaten. De machines hebben grote instructiesets, een ontwikkeld systeem software, inclusief vertalers voor de programmeertalen Assembly, FORTRAN, PL/1, COBOL, ALGOL, PASCAL, besturingssystemen met verschillende functionaliteit. Het belangrijkste kenmerk van besturingscomputers...

Lijst vertegenwoordigt een verzameling dynamische objecten van hetzelfde type, georganiseerd met behulp van links.

Objecten worden lijstelementen genoemd. Een element van een lijst is meestal een item dat bevat: ten minste, twee velden (Fig. 2.13):

Informatief;

Wijzer.

De lijst zelf wordt gepresenteerd in de vorm van Fig. 2.14.

Elk lijstelement heeft wijzer op de buurman. Het laatste element heeft een aanwijzer - Nihil. Lijstelementen en verwijzingen worden als volgt beschreven:

Index = ^El_Lijst;(Vooraf beschrijving)

(alleen toegestaan ​​in dit geval)

E-Lijst = Record

Inf._ veld: Veld_Info_Type;

Indexveld: Index; (Dit type is hierboven al gedefinieerd)

Het type informatie-element is willekeurig (scalair, string, array, etc.).

Voorbeeld. Tja

Ptr = ^ El;

El = Opnemen

Buk: Char;

Ukaz: Ptr;

tuk, Pr, Nuk,q:Ptr;(Verwijzingen naar een lijstelement)

ElSp : El; ( Lijstelement (recordtype El) }

Lijsten maken het gemakkelijk om te presenteren wachtrijen.

Wachtrij is een concept dat veel wordt gebruikt in de computerwereld. Met een lijst kunt u de bewerkingen modelleren van het toevoegen van elementen aan een wachtrij en het selecteren ervan.

Basisbewerkingen op lijsten:

1) overgang van het ene element naar het andere (volgende);

2) opname van een nieuw element in de lijst;

3) een element uit de lijst verwijderen.

1) De eerste handeling is eenvoudig: aan de waarde van de pointervariabele, die nu naar een bepaald element verwijst, moet de waarde worden toegewezen die zich in het pointerveld van dit element bevindt (zie Fig. 2.15):

tuk := tuk^. Ukaz

IN resultaat tuk wordt een link naar het volgende element of Nihil, als het element het laatste is.

2) Verwijdering element uit de lijst wordt het eenvoudigst uitgevoerd als er een link (pointer) naar het element is, vorig verwijderd. In dit geval worden de links eerst overgedragen en vervolgens wordt het element verwijderd (het dynamische geheugen dat het in beslag neemt, wordt vrijgegeven). De verwijzing naar het element dat wordt verwijderd mag niet verloren gaan totdat het wordt vernietigd of in een andere lijst wordt opgenomen, anders wordt het "afval".

Het proces waarbij een element in een lijst wordt verwijderd nadat het element waarnaar door een link wordt verwezen, wordt verwijderd Pr, geïllustreerd in afb. 2.16, en een fragment van het corresponderende programma kan er als volgt uitzien.

{Onthoud de verwijzing naar het element dat moet worden verwijderd)

tUk:= PrUk^.Ukaz;

(Wijs het pointerveld toe van het element dat voorafgaat aan het element dat moet worden verwijderd)

(de waarde van het pointerveld van het element dat moet worden verwijderd)

PrUk^.Ukaz:= PrUk^.Ukaz^.Ukaz;

Hierop verwijdering element uit de lijst voltooid: de verbinding van dit element met het vorige is verbroken. Maar het element blijft geheugen in beslag nemen en om het fysiek te verwijderen, moet u de procedure uitvoeren:

Verwijderen(tUk); (Het element fysiek verwijderd)

Als het niet nodig is om geheugen vrij te maken, is het soms handig om naar het aanwijzerveld van het verwijderde element te schrijven Nihil:

tUk^.Ukaz:= nul.

3)Inschakelen naar de lijst met het element waarnaar een verwijzing bestaat NGroot-Brittannië, na het element waarnaar een verwijzing verwijst Pr, geïllustreerd in afb. 2.17. Om deze bewerking uit te voeren, moet u een link instellen van het ingevoegde element naar het volgende (deze is gelijk aan de link van het vorige element naar het volgende - zie Fig. 2.17, a), en vervolgens de link wijzigen van de vorig element ten opzichte van het ingevoegde element (zie Fig. 2.17, b) . De bestaande verbinding wordt als laatste verbroken om het element niet te verliezen.

Het programmafragment ziet er als volgt uit

Nieuw(NUk);

(Een ingevoegd element gemaakt)