Ang klase ng TList ay idinisenyo upang mag-imbak ng isang listahan ng mga pointer sa mga istruktura na matatagpuan sa espasyo ng address (mga bagay, mga dynamic na array, mga variable). Tulad ng TstringList, ang listahan ng pointer ay nagbibigay mabisang gawain na may mga elemento ng listahan.
Klase sa TList
Ang core ng klase ng TList ay isang listahan ng mga pointer. Ang listahan mismo ay isang dynamic na hanay ng mga pointer na maaaring ma-access sa pamamagitan ng isang naka-index na property
Mga item ng ari-arian: Pointer;
Ang pagbilang ng mga elemento ay nagsisimula sa zero.
Ang direktang access sa mga elemento ng array ay posible sa pamamagitan ng property
uri
PPointerList = ^TPointerList;
TPointerList = hanay ng Pointer;
Listahan ng ari-arian: PPointerList;
na mayroong read-only na katangian.
Dahil ang mga elemento ng listahan ay mga pointer sa ilang mga istraktura, direktang ina-access mga bahagi ng mga istrukturang ito sa pamamagitan ng mga item na ari-arian ay hindi posible.
Kung paano ito magagawa ay inilarawan sa halimbawa sa ibaba.
Tandaan
Ang listahan ay maaaring maglaman ng mga pointer sa magkakaibang mga istraktura. Hindi kinakailangang mag-imbak lamang ng mga pointer sa mga bagay o pointer sa mga talaan sa isang listahan.
Ang mga pagpapatakbo ng listahan na ipinatupad sa klase ng TList ay nakakatugon sa mga pangangailangan ng developer at nag-tutugma sa mga pagpapatakbo ng isang listahan ng mga string.
Upang magdagdag ng bagong pointer sa dulo ng listahan, gamitin ang paraan
function Add(Item: Pointer): Integer;
Ang direktang pagtatalaga ng value sa isang elemento na hindi pa nagagawa gamit ang Add method ay magdudulot ng error sa run-time.
Maaaring magdagdag ng bagong index sa gustong lokasyon sa listahan. Para sa layuning ito ang pamamaraan ay ginagamit
procedure Insert(Index: Integer; Item: Pointer);
Tinutukoy ng index parameter ang kinakailangang sequence number sa listahan.
Ang paglilipat ng isang umiiral na elemento sa isang bagong lokasyon ay isinasagawa gamit ang pamamaraan
procedure Move(Curlndex, Newlndex: Integer);
Tinutukoy ng parameter ng CurIndex ang lumang posisyon ng pointer. Tinutukoy ng parameter ng NewIndex ang bagong posisyon nito.
Maaari ka ring magpalit ng dalawang elemento na tinukoy ng mga parameter ng Indexl at Index2:
procedure Exchange(Indexl, Index2: Integer);
Mayroong dalawang paraan na ginagamit upang alisin ang mga pointer mula sa isang listahan. Kung ang index ay kilala, ang paraan ay ginagamit
procedure Delete(Index: Integer);
Kung ang pointer mismo ay kilala, ang pamamaraan ay ginagamit
Hindi binabawasan ng mga pamamaraang ito ang dami ng memorya na inilalaan sa listahan. Kung kinakailangan, dapat mong gamitin ang capacity property para gawin ito. Mayroon ding paraan ng Expand na awtomatikong nagpapataas ng inilalaan na memorya depende sa kasalukuyang laki ng listahan.
function Palawakin: TList;
Upang gumana ang pamamaraan, kinakailangan na bilangin = Kapasidad.
Pamamaraan
pamamaraan Malinaw; dynamic;
ginagamit upang alisin ang lahat ng elemento ng isang listahan nang sabay-sabay. Upang maghanap ng pointer ayon sa halaga nito, gamitin ang pamamaraan
function IndexOf(Item: Pointer): Integer;
Ibinabalik ng pamamaraan ang index ng nahanap na elemento sa listahan. Kung hindi matagumpay ang paghahanap, babalik ito - 1.
Upang ayusin ang mga elemento ng listahan, gamitin ang pamamaraan
procedure Sort(Ihambing: TListSortCompare);
Dahil ang komposisyon ng istraktura kung saan ang mga punto ng elemento ng listahan ay hindi maaaring pangkalahatan nang maaga, ang pagbuo ng isang pamamaraan na nagsasagawa ng pag-uuri ay ipinagkatiwala sa programmer. Ang paraan ng Pag-uuri ay nagbibigay lamang ng isang pairwise na paghahambing ng mga pointer batay sa isang algorithm na ginawa ng programmer (para sa isang halimbawa ng pag-uuri, tingnan sa itaas sa seksyong "TStringList Class").
Ang lahat ng mga katangian at pamamaraan ng klase ng TList ay ipinakita sa Talahanayan. 7.2.
Talahanayan 7.2. Mga katangian at pamamaraan ng klase ng TList
Anunsyo
Paglalarawan
property Capacity: Integer;
Tinutukoy ang bilang ng mga hilera kung saan inilalaan ang memorya
Bilang ng ari-arian: Integer;
Ibinabalik ang bilang ng mga row sa isang listahan
Mga item ng ari-arian : Pointer;
Listahan ng mga payo
uri
TPointerList = hanay ng Pointer;
PPointerList = ATPointerList; Listahan ng ari-arian: PPointerList;
Dynamic na hanay mga payo
function Add(Item: Pointer): Integer;
Nagdaragdag ng bagong pointer sa listahan
pamamaraan Malinaw; dynamic;
Ganap na nililinis ang listahan
pamamaraan na Tanggalin (Index: Integer:;
Tinatanggal ang isang pointer na may index
Index
class procedure Error (const Ksg: string; Data: Integer); virtual;
Bumubuo ng pambihirang
Sitwasyon ng EListError.
Ang mensahe ng error ay nabuo mula sa string ng format ng Msg at ang parameter ng numeric na Data
procedure Exchange(Indexl, Index2: Integer);
Pinapalitan ang mga pointer gamit ang Indexl at Index2
function Palawakin: TList;
Pinapataas ang laki ng memorya na inilaan para sa listahan
function Una: Pointer;
Ibinabalik ang unang pointer mula sa isang listahan
function IndexOf(Item: Pointer): Integer;
Ibinabalik ang index ng pointer, tinukoy ng parameter item
procedure Insert (Index: Integer; Item: Pointer) ;
Mga pagsingit bagong elemento Index ng posisyon ng mga item
Huling function: Pointer;
Ibinabalik ang huling pointer sa listahan
procedure Move(Curlndex, Newlndex: Integer);
Inilipat ang isang item sa listahan sa isang bagong lokasyon
pakete ng pamamaraan;
Tinatanggal ang lahat ng null (Nil) pointer mula sa isang listahan
function na Alisin(Item: Pointer): Integer;
Nag-aalis ng pointer sa listahan
item
uri TListSortCompare = function (Iteml, Item2: Pointer): Integer;
procedure Sort(Ihambing: TListSortCompare);
Pag-uuri ng mga item sa listahan
Halimbawa ng paggamit ng listahan ng mga pointer
Tingnan natin ang paggamit ng mga listahan ng mga pointer gamit ang halimbawa ng DemoList application.
Kapag nag-click ka sa application form, isang tuldok ang ipapakita, na nakatalaga ng serial number. Kasabay nito, ang mga coordinate at point number ay isinusulat sa mga kaukulang katangian ng nilikhang instance ng klase ng TMypixel. Ang isang pointer sa bagay na ito ay ipinasa sa bagong pixList.
Bilang resulta, pagkatapos i-clear ang form, ang buong pagkakasunud-sunod ng mga puntos ay maaaring maibalik gamit ang mga pointer upang ituro ang mga bagay mula sa listahan.
Ang listahan ng mga puntos ay maaaring pagbukud-bukurin ayon sa X coordinate sa pataas na pagkakasunud-sunod.
Listahan. Module ng pangunahing anyo ng proyekto ng DemoList
Pangunahing Yunit;
interface
gamit
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
uri
Mga Dialog, StdCtrls, Mga Pindutan;
TMainForm = klase(TForm)
ListBtn: TBitBtn;
ClearBtn: TBitBtn;
DelBtn: TBitBtn;
SortBtn: TBitBtn;
pamamaraan FormCreate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
pamamaraan FormMouseDown(Sender: TObject; Button: TMouseButton;
procedure ListBtnClick(Sender: TObject);
pamamaraan ClearBtnClick(Sender: TObject);
pamamaraan DelBtnClick(Sender: TObject);
pamamaraan SortBtnClick(Sender: TObject);
pribado
PixList: TList;
PixNum: Integer; pampubliko
(Mga pampublikong deklarasyon)
wakas;
TMyPixel = klase(TObject)
fx:integer;
FY: Integer;
FText: Integer;
constructor Create(X, Y, Num: Integer);
(Mga pampublikong deklarasyon)
pamamaraan SetPixel;
var
MainForm: TMainForm;
pagpapatupad
($R *.DFM)
const PixColor = clRed;
var CurPixel: TMyPixel;
constructor TMyPixel.Create(X, Y, Num: Integer);
magsimula
minana ang Lumikha;
FX:=X;
FY:=Y;
FText:= Num;
(Mga pampublikong deklarasyon)
SetPixel;
constructor TMyPixel.Create(X, Y, Num: Integer);
pamamaraan TMyPixel.SetPixel;
MainForm.Canvas.PolyLine();
(Mga pampublikong deklarasyon)
MainForm.Canvas.TextOut(FX +1, FY + 1, IntToStr(FText));
function na PixCompare(Iteml, Item2: Pointer): Integer;
constructor TMyPixel.Create(X, Y, Num: Integer);
var Pixel, Pix2: TMyPixel;
Pixl: = Iteml;
Pix2: = Item2;
(Mga pampublikong deklarasyon)
Resulta:= Pixl.FX - Pix2.FX;
constructor TMyPixel.Create(X, Y, Num: Integer);
pamamaraan TMainForm.FormCreate(Sender: TObject);
PixList:= TList.Create;
PixNum:= 1; (Point counter)
Canvas.Pen.Color:= PixColor; (Kulay ng tuldok)
Canvas.Pen.Width:= 3; (Laki ng tuldok)
(Mga pampublikong deklarasyon)
Canvas.Brush.Color:= Kulay; (Ang kulay ng background ng teksto ay katumbas ng kulay ng form)
constructor TMyPixel.Create(X, Y, Num: Integer);
procedure TMainForm.FormClose(Sender: TObject; var Action: TCloseAction);
(Mga pampublikong deklarasyon)
PixList.Free;
Shift: TShiftState; X, Y: Integer);
constructor TMyPixel.Create(X, Y, Num: Integer);
PixList.Add(TMyPixel.Create(X, Y, PixNum));
Inc(PixNum);
(Mga pampublikong deklarasyon)
pamamaraan TMainForm.ListBtnClick(Sender: TObject);
var i: Integer;
constructor TMyPixel.Create(X, Y, Num: Integer);
gamit ang PixList do
para sa i:= 0 sa Bilang - 1 gawin
constructor TMyPixel.Create(X, Y, Num: Integer);
CurPixel:= Mga Item[i]; CurPixel.SetPixel;
wakas; wakas;
pamamaraan TMainForm.ClearBtnClick(Sender: TObject);
constructor TMyPixel.Create(X, Y, Num: Integer);
Canvas.FillRect(Rect(0, 0, Lapad, Taas));
(Mga pampublikong deklarasyon)
procedure TMainForm.DelBtnClick(Sender: TObject);
constructor TMyPixel.Create(X, Y, Num: Integer);
PixList.Clear;
PixNum:= 1;
(Mga pampublikong deklarasyon)
pamamaraan TMainForm.SortBtnClick(Sender: TObject);
var i: Integer;
constructor TMyPixel.Create(X, Y, Num: Integer);
PixList.Sort(PixCompare);
gamit ang PixList do
para sa i:= 0 hanggang Bilang - 1 sa TMyPixel(Mga Item[i]).FText:= i + 1;
(Mga pampublikong deklarasyon)
wakas.
Ang klase ng TMyPixel ay nagbibigay ng imbakan ng mga coordinate ng isang punto at ang serial number nito sa serye. Ang mga parameter na ito ay ipinasa sa tagabuo ng klase. Tinitiyak ng paraan ng setPixel na ang isang punto ay iguguhit sa outline ng form.
Ang isang halimbawa ng klase ay nilikha para sa bawat isa bagong punto kapag na-click ang pindutan ng mouse sa paraan ng handler ng FormMouseDown. Narito ang isang pointer sa bagong bagay naka-save sa elemento ng listahan ng PixList na ginawa gamit ang Add method.
Kaya, "naaalala" ng programa ang lokasyon at pagkakasunud-sunod ng mga puntos.
Tinitiyak ng paraan ng handler ng ListBtnClick na ang mga puntos ay ipinapakita. Upang gawin ito, sa isang loop, ang kasalukuyang list pointer ay inililipat sa isang variable ng uri ng object na curPixel, ibig sabihin, ang variable na ito ay "bisitahin" naman ng lahat ng nilikha na mga bagay, ang mga pointer kung saan naka-imbak sa listahan.
Ginagawa ito upang makakuha ng access sa mga katangian ng mga bagay (hindi ito maaaring gawin nang direkta sa pamamagitan ng isang pointer). Ang pangalawang uri ng paraan ng paghahagis ay tinalakay sa paraan ng SortBtnClick handler.
Bago ipakita muli ang mga punto, ang ibabaw ng form ay dapat na malinis.
Isinasagawa ang operasyong ito sa pamamagitan ng clearBtnClick handler method. Ang listahan ng mga puntos ay maaaring pagbukud-bukurin ayon sa X coordinate sa pataas na pagkakasunud-sunod. Upang gawin ito, ang Sort method ng PixList ay tinatawag sa SortBtnClick handler method. Ang parameter ng pamamaraan (procedural type variable) ay pumasa sa PixCompare function, na nagbibigay ng mekanismong naka-encapsulated sa Sort method para sa pag-enumerate ng mga elemento ng listahan na may algorithm para sa pagpapasya sa precedence ng dalawang magkatabing elemento. Kung babalik ang function positibong numero
Sa aming kaso, ang X coordinate ng dalawang puntos ay inihambing. Bilang resulta ng pataas na pag-uuri na ito, ang mga bagay ay inayos upang ang unang elemento ng listahan ay tumuturo sa bagay na may pinakamababang X coordinate, at ang huling elemento ay tumuturo sa bagay na may pinakamataas na X coordinate.
Pagkatapos ng pag-uuri, ang natitira na lang ay muling bilangin ang lahat ng mga puntos. Gumagawa ito ng loop sa paraan ng SortBtnclick handler. Tandaan ang uri ng pag-cast na ginamit sa kasong ito, na nagbibigay ng access sa mga katangian ng mga pagkakataon ng klase ng TMypixel.
Nagbibigay ang paraan ng handler ng DeiBtnClick kumpletong paglilinis ilista ang pixList.
Panimula
1. Kahulugan ng ADT
3. Paglalarawan ng mga operasyon
3.1 Magdagdag ng pagpapatakbo ng elemento
3.2 Ang operasyon ng pagdaragdag ng isang elemento pagkatapos ng tinukoy na isa
3.3 Tanggalin ang operasyon tinukoy na elemento
3.4 Ilista ang Entry Print Operation
4. Pagpapatupad ng ADT-list
4.2 Interface
4.3 Pagpapatupad ng mga pamamaraan
Konklusyon
Mga sanggunian
Appendix A: Mga Algorithm Graph
Panimula
Anuman ang uri ng problema na nalutas, ang anumang programa ay nagpapatakbo sa ilang uri ng data, at ang program mismo ay kumakatawan sa mga pamamaraan para sa pamamahala at pagproseso ng data na ito. Ang bilis kung saan nakumpleto ng isang programa ang isang naibigay na gawain ay nakasalalay hindi lamang sa mga algorithm na ginagamit nito upang iproseso at pamahalaan ang data, kundi pati na rin sa organisasyon ng data mismo. Kaya, dumating tayo sa konsepto ng mga istruktura ng data.
Ang direktang pakikipag-ugnayan sa pagitan ng programa sa pamamagitan ng user at mga istruktura ng data ay nag-iiwan ng maraming data, ang pagbabago nito sa isang hindi lehitimong paraan (pag-bypass sa interface) ay maaaring humantong sa hindi kanais-nais na mga kahihinatnan. Para makalampas ang problemang ito kinakailangan na "bumuo ng mga pader" sa pagitan ng data at ng programa, na nag-iiwan lamang ng isang "window" sa anyo ng isang interface. Upang gawin ito, kinakailangan upang tukuyin ang mga abstract na uri ng data kung saan ang mga pader na ito ay itinayo.
Sa gawaing ito, isang abstract data type (ADT) ay binuo - isang listahan, na pagkatapos ay ipinatupad bilang isang naka-link na listahan, na ipinatupad gamit ang pointer-based na indirection. Ang pagbuo ng ADT ay tinalakay nang mas detalyado sa.
1. Kahulugan ng ADT
Inilalarawan ng abstraction ng data kung ano ang maaaring gawin sa isang set ng data, hindi pinapansin ang tanong na "paano ito ginagawa?" Ang abstraction ng data ay isang paraan upang bumuo mga indibidwal na sangkap programa, anuman ang natitirang bahagi nito (iba pang mga bahagi). Kaya, ang data abstraction ay isang natural na extension ng functional abstraction, na nagpapahintulot sa mga function na mabuo sa relatibong paghihiwalay sa isa't isa. Ang isang set ng data na pinagsama sa isang set ng mga operasyon dito ay tinatawag na abstract data type. Ang paglalarawan ng mga operasyong kasama sa ADT ay dapat na sapat na mahigpit upang tumpak na ipahiwatig ang kanilang epekto sa data. Ngunit hindi nito dapat tukuyin kung paano iniimbak ang data o mga detalye ng mga operasyon. Tiyak na paraan ang data storage (data structure) ay pinipili lamang kapag nagpapatupad ng ADT. Ang istraktura ng data ay isang construct na tinukoy sa isang programming language para sa pag-iimbak ng isang set ng data. Ayon sa opsyon sa pagtatalaga, ang sumusunod na data ay tinukoy:
1. Pangalan ng chip
2. Gastos
3. Dami
Ang mga sumusunod na operasyon ay tinukoy sa kanila:
1.Pagdaragdag ng elemento sa isang hindi nakaayos na listahan
2.Pag-alis ng isang elemento na may ibinigay na field mula sa isang hindi nakaayos na listahan
3.Pagdaragdag ng isang elemento pagkatapos ng tinukoy
4.Pagtanggal ng lahat ng elemento na may ibinigay na field
5. I-print ang listahan
Itong set tumutukoy sa hanay ng mga pinahihintulutang operasyon sa data na tinukoy sa gawain, i.e. binibigyan kami ng abstract na uri ng data.
2. Pangkalahatang mga probisyon
Ang isang abstract na listahan ay maaaring ipatupad bilang isang array - sa unang tingin, isang malinaw na hakbang. Ang array ay may nakapirming laki(sa karamihan ng mga programming language), habang ang haba ng abstract na listahan ay walang limitasyon. Kaya, ang istraktura ng data ay nagiging static, na isang kawalan.
Isa pa makabuluhang sagabal ay isang pagpapatuloy ng bentahe ng mga arrays - ang sunud-sunod na pag-aayos ng data sa katabing mga cell, sa madaling salita, madalas na ginawa, samakatuwid, nangangailangan pinakamataas na bilis pagpapatupad, mga operasyon tulad ng pagpasok at pagtanggal ng isang elemento ay humahantong sa pangangailangan na ilipat ang mga elemento ng array, paggastos dagdag na oras.
Ang prinsipyo ng pagpapatupad ng isang listahan na hindi gumagamit ng paglilipat ng elemento ay batay sa hindi direktang pagtugon. Ang iba pang mga paraan upang ipatupad ang mga abstract na listahan ay inilarawan nang detalyado sa.
Bawat node naka-link na listahan ay binubuo ng dalawang bahagi: ang data mismo at isang pointer sa susunod na elemento - ang parehong node o isang NULL constant.
Dahil, ayon sa prinsipyo ng encapsulation, ang data ay dapat ma-access lamang sa pamamagitan ng mga pamamaraan na tinukoy para sa layuning ito, ang pribadong access specifier ay tinukoy para sa data.
Kasama sa mekanismo para sa paglalaan ng memorya para sa mga elemento ng isang listahan na nakabatay sa pointer dinamikong pagpili gamit ng memorya bago ang mga operator at tanggalin. Kaya, kapag lumilikha ng isang bagong elemento, makatuwiran na maglaan ng memorya lamang para sa bagong data, at hindi para sa na ilang mga pamamaraan– listahan ng mga operasyon. Samakatuwid, ito ay kinakailangan upang alisin ang mga pamamaraan mula sa istraktura ng data. Sa gawaing ito, ginamit ang isang pamamaraan upang mapalawak ang interface sa pamamagitan ng paglikha ng istraktura ng pamamaraan - isang magiliw na klase na ang mga pamamaraan ay may access sa mga pribadong miyembro ng klase ng node.
Maaari kang matuto nang higit pa tungkol sa mga prinsipyo ng object-oriented programming mula sa.
Ang mga pointer sa ulo at buntot ng isang listahan ay idineklara sa klase ng Listahan dahil ang mga ito ay mahalagang kinakailangan para sa pagpapatupad ng mga pamamaraan ng ADT, habang para sa mismong istraktura ng data ay hindi nila naiintindihan ang kaunting kahulugan.
Ang mga pamamaraan na hindi dapat baguhin ang data sa anumang paraan ay idineklara gamit keyword const.
Isagawa ang lahat ng mga aksyon tulad ng sa mga ordinaryong variable. Upang magtrabaho kasama dynamic na pamamahagi memorya ay napaka-maginhawang gamitin mga kaugnay na istruktura data, gaya ng mga single linked list. Ang pinakasimpleng halimbawa ng isang listahan ay isang array kung saan ang lahat ng mga elemento nito ay nakaayos nang sunud-sunod. Ngunit ang representasyong ito ay may isang makabuluhang disbentaha - kinakailangan upang tumpak na tukuyin ang bilang ng mga elemento nang maaga...
Diskarte sa pag-unlad mahusay na algorithm Upang malutas ang anumang problema, kailangan mong pag-aralan ang kakanyahan nito. Kadalasan, ang problema ay maaaring mabuo sa wika ng set theory, na kabilang sa mga pangunahing sangay ng matematika. Sa kasong ito, ang algorithm para sa paglutas nito ay maaaring isaad sa mga tuntunin ng mga pangunahing operasyon sa mga set. Kasama rin sa mga naturang gawain ang mga gawain pagkuha ng impormasyon kung saan nareresolba ang mga problema...
Mas magkakaroon ng kahulugan ang data kung ito ay pag-uuri-uriin sa ilang paraan. Kadalasan kailangan mong pag-uri-uriin ang data ayon sa ilan sa iba't ibang paraan. Pangalawa, maraming mga algorithm ng pag-uuri kawili-wiling mga halimbawa programming. Nagpapakita sila ng mahahalagang diskarte tulad ng bahagyang pag-order, recursion, pagsasama ng listahan, at pag-iimbak ng mga binary tree sa isang array. Sa wakas, pag-uuri-uriin...
Power (palitan ang mga processor), palawakin ang kapasidad RAM, idagdag mga panlabas na aparato. Ang mga makina ay may malalaking set ng pagtuturo, binuo na sistema software, kabilang ang mga tagasalin para sa mga programming language na Assembler, FORTRAN, PL/1, COBOL, ALGOL, PASCAL, mga operating system na may iba't ibang pag-andar. Ang pangunahing tampok ng control computer...
Listahan kumakatawan sa isang koleksyon mga dynamic na bagay ng parehong uri, na nakaayos gamit ang mga link.
Ang mga bagay ay tinatawag na mga elemento ng listahan. Ang isang elemento ng isang listahan ay karaniwang isang entry na naglalaman ng, kahit man lang, dalawang field (Larawan 2.13):
Pang-impormasyon;
Pointer.
Ang listahan mismo ay ipinakita sa anyo ng Fig. 2.14.
Ang bawat elemento ng listahan ay may panturo sa kapitbahay. Ang huling elemento ay may pointer - Wala. Ang mga elemento ng listahan at mga pointer ay inilarawan bilang mga sumusunod:
Index = ^El_List;(Paunang paglalarawan)
(pinapayagan lamang sa kasong ito)
E-List = Record
Inf._ patlang: Field_Info_Type;
Index_field: Index; (Ang uri na ito ay tinukoy na sa itaas)
Ang uri ng elemento ng impormasyon ay anuman (scalar, string, array, atbp.).
Halimbawa. Type
Ptr = ^El;
El = Record
Buk: Char;
Ukaz: Ptr;
tUk, PrUk, NUk,q:Ptr;(Mga pointer sa isang elemento ng listahan)
ElSp : El; ( Elemen ng listahan (uri ng record El) }
Pinapadali ng mga listahan ang paglalahad mga pila.
Nakapila ay isang konsepto na malawakang ginagamit sa computing. Binibigyang-daan ka ng isang listahan na imodelo ang mga pagpapatakbo ng pagdaragdag ng mga elemento sa isang queue at pagpili mula dito.
Mga pangunahing operasyon sa mga listahan:
1) paglipat mula sa isang elemento patungo sa isa pa (susunod);
2) pagsasama ng isang bagong elemento sa listahan;
3) pag-alis ng isang elemento mula sa listahan.
1) Ang unang operasyon ay simple: ang halaga ng pointer variable, na ngayon ay tumuturo sa isang partikular na elemento, ay dapat na italaga ang halaga na matatagpuan sa pointer field ng elementong ito (tingnan ang Fig. 2.15):
tUk := tUk^. Ukaz
SA 
resulta tUk ay magiging isang link sa susunod na elemento o Wala, kung ang elemento ay huli.
2) Pagtanggal Ang elemento mula sa listahan ay ginagawa nang simple kung mayroong isang link (pointer) sa elemento, dati tinanggal. Sa kasong ito, ang mga link ay unang inilipat, at pagkatapos ay ang elemento ay tinanggal (ang dynamic na memorya na sinasakop nito ay napalaya). Ang reference sa elementong tinatanggal ay hindi dapat mawala hanggang sa ito ay masira o maisama sa isa pang listahan, kung hindi, ito ay magiging "basura".
Ang proseso ng pag-alis ng isang elemento na matatagpuan sa isang listahan pagkatapos ng elementong itinuro ng isang link PrUk, na inilalarawan sa Fig. 2.16, at ang isang fragment ng kaukulang programa ay maaaring magmukhang katulad ng nasa ibaba.
{
Tandaan ang pointer sa elementong tatanggalin)
tUk:= PrUk^.Ukaz;
(Italaga ang pointer field ng elemento na nauuna sa isa na tatanggalin)
(ang halaga ng pointer field ng elemento na aalisin)
PrUk^.Ukaz:= PrUk^.Ukaz^.Ukaz;
Tungkol dito pagtanggal elemento mula sa listahan tapos na: nasira ang koneksyon ng elementong ito sa nauna. Ngunit ang elemento ay patuloy na sumasakop sa memorya at upang pisikal na tanggalin ito kailangan mong isagawa ang pamamaraan:
Itapon(tUk); (Phisikal na inalis ang elemento)
Kung hindi na kailangang magbakante ng memorya, kung minsan ay kapaki-pakinabang na sumulat sa tinanggal na patlang ng pointer ng elemento Wala:
tUk^.Ukaz:= Nil.
3
)Pinapagana sa listahan ng elemento kung saan mayroong pointer NUK, pagkatapos ng elemento kung saan mayroong isang pointer PrUk, na inilalarawan sa Fig. 2.17. Upang maisagawa ang operasyong ito, kailangan mong magtakda ng isang link mula sa ipinasok na elemento patungo sa susunod (ito ay katumbas ng link mula sa nakaraang elemento hanggang sa susunod - tingnan ang Fig. 2.17, a), at pagkatapos ay baguhin ang link mula sa nakaraang elemento sa ipinasok (tingnan ang Fig. 2.17, b). Ang umiiral na koneksyon ay huling nasira upang hindi mawala ang elemento.
Ang fragment ng programa ay magiging hitsura
Bago(NUk);
(Gumawa ng nakasingit na elemento)
