Lingitud loendi lõppsõlm, millel on silmus, viitab NULL asemel teisele samas loendis olevale sõlmele. Kui lingitud loendis on sõlm, millele saab korduvalt juurde pääseda, järgides järgmist kursorit, öeldakse, et loend on tsükkel.
Tavaliselt viitab lingitud loendi viimane sõlm NULL-i viitele, mis tähistab loendi järeldust. Silmusega lingitud loendis viitab loendi lõppsõlm aga algussõlmele, sisemisele sõlmele või iseendale. Seetõttu peame sellistel asjaoludel tuvastama ja lõpetama ahela, määrates järgmise sõlme viite väärtusele NULL. Lingitud loendis oleva ahela tuvastamise osa selgitatakse selles artiklis.
C++-s on lingitud loendist silmuste leidmiseks mitmeid viise:
Räsitabelipõhine lähenemine : See lähenemisviis salvestab külastatud sõlmede aadressid räsitabelisse. Lingitud loendis on silmus, kui sõlm on räsitabelis juba selle uuesti külastamisel olemas.
Floydi tsükli lähenemine : 'Kilpkonna ja jänese' algoritm, üldtuntud kui Floydi tsükliotsingu algoritm: see tehnika kasutab kahte osutit, millest üks liigub aeglasemalt kui teine ja teine kiiremini. Kiirem osuti möödub lõpuks aeglasemast, kui lingitud loendis on silmus, mis näitab tsükli olemasolu.
Rekursiivne meetod : see meetod läbib lingitud loendit, kutsudes ennast ikka ja jälle. Lingitud loend sisaldab tsüklit, kui praegust sõlme on varem külastatud.
Stack-põhine lähenemine : see lähenemisviis salvestab külastatud sõlmede aadressid virna. Lingitud loendis on tsükkel, kui sõlm on juba virnas, kui seda uuesti külastatakse.
Mõiste mõistmiseks selgitame iga lähenemisviisi üksikasjalikult.
1. lähenemisviis: räsikomplekti lähenemisviis
Räsi kasutamine on kõige lihtsam meetod. Siin läbime loendi ükshaaval, säilitades samal ajal sõlme aadressidega räsitabeli. Seetõttu on silmus olemas, kui me kunagi jookseme üle praeguse sõlme järgmise aadressi, mis on juba räsitabelis. Vastasel juhul pole lingitud loendis tsüklit, kui satume NULL-i (st jõuame lingitud loendi lõppu).
Seda strateegiat on üsna lihtne rakendada.
Lingitud loendi läbimisel kasutame unordered_hashmapi ja jätkame sellele sõlmede lisamist.
Nüüd, kui oleme kohanud sõlmpunkti, mis on juba kaardil näidatud, teame, et oleme jõudnud tsükli algusesse.
-
- Lisaks hoidsime igal sammul kaks osutit, peasõlm osutades praegusele sõlmele ja lastNode osutab itereerimise ajal praeguse sõlme eelnevale sõlmele.
- Nagu meie peasõlm näitab nüüd tsükli algussõlme ja as lastNode osutas sõlmele, millele pea osutas (st see viitab lastNode tsüklist), meie peasõlm osutab praegu tsükli algussõlmele.
- Silmus katkeb seadistusega l astNode->next == NULL .
Seda tehes hakkab tsükli algsõlmele viitamise asemel tsükli lõppsõlm osutama NULL-ile.
Räsimeetodi keskmine aja ja ruumi keerukus on O(n). Lugeja peaks alati teadma, et sisseehitatud räsiandmete struktuuri rakendamine programmeerimiskeeles määrab räsimise kokkupõrke korral aja kogu keerukuse.
C++ programmi rakendamine ülaltoodud meetodi jaoks (HashSet):
#include
kasutades nimeruumi std;
struktuuri sõlm {
int väärtus;
struktuuri sõlm * järgmine;
} ;
Sõlm * uusSõlm ( int väärtus )
{
Sõlm * tempNode = uus sõlm;
tempNode- > väärtus = väärtus;
tempNode- > järgmine = NULL;
tagasi tempNode;
}
// Tuvastage ja kõrvaldage võimalikud silmused
// sisse selle funktsiooniga lingitud loend.
tühine funktsioonHashMap ( Sõlm * peasõlm )
{
// Lõi räsikaardi rakendamiseks unordered_map
tellimata_kaart < Sõlm * , int > hash_map;
// osutaja viimasele sõlmele
Sõlm * lastNode = NULL;
samal ajal ( peasõlm ! = NULL ) {
// Kui sõlm kaardil puudub, lisage see.
kui ( hash_map.find ( peasõlm ) == hash_map.end ( ) ) {
hash_map [ peasõlm ] ++;
lastNode = headNode;
headNode = headNode- > järgmine;
}
// Kui tsükkel on olemas, seatud viimane sõlm 'i järgmine kursor NULL-ile.
else {
lastNode->next = NULL;
murda;
}
}
}
// Kuva lingitud loend
tühikuur (sõlm* peasõlm)
{
while (headNode != NULL) {
cout << headNode->value << ' ';
headNode = headNode-> next;
}
cout << endl;
}
/* Põhifunktsioon*/
int main()
{
Sõlm* headNode = uusSõlm(48);
headNode->next = headNode;
headNode->next = uusSõlm(18);
headSõlm->järgmine->järgmine = uusSõlm(13);
headSõlm->järgmine->järgmine->järgmine = uusSõlm(2);
headNode-> next-> next-> next-> next = newNode(8);
/* Loo linkedList tsükkel */
headNode-> next-> next-> next-> next-> next = headNode-> next-> next;
functionHashMap(headNode);
printf('Lingitud loend ilma tsüklita \n');
kuva(headNode);
tagasi 0;
}
Väljund:
Lingitud loend ilma tsüklita
48 18 13 2 8
Koodi samm-sammult selgitus on toodud allpool:
-
- Päisefail bits/stdc++.h>, mis sisaldab kõiki tavalisi C++ teeke, on lisatud koodi.
- Koostatakse struktuur nimega 'Sõlm' ja sellel on kaks liiget: viide loendi järgmisele sõlmele ja täisarv nimega 'väärtus'.
- Kui sisendiks on täisarv ja 'järgmine' osuti on seatud väärtusele NULL, loob funktsioon 'newNode' selle väärtusega uue sõlme.
- Funktsioon ' functionHashMap' on määratletud, mis võtab sisendiks kursori lingitud loendi peasõlmele.
- ' FunctionHashMap ', luuakse järjestamata_kaart nimega 'hash_map', mida kasutatakse räsikaardi andmestruktuuri rakendamiseks.
- Osuti loendi viimasele sõlmele lähtestatakse väärtuseks NULL.
- Lingitud loendi läbimiseks kasutatakse while-tsüklit, mis algab peasõlmest ja jätkub seni, kuni peasõlm on NULL.
- Kui praegune sõlm (headNode) ei ole räsikaardil juba olemas, värskendatakse lastNode'i osuti while-tsükli sees olevaks praeguseks sõlmeks.
- Kui praegune sõlm leitakse kaardil, tähendab see, et lingitud loendis on silmus. Silmuse eemaldamiseks tuleb järgmine kursor lastNode on seatud NULL ja while-tsükkel on katki.
- Lingitud loendi peasõlme kasutatakse funktsiooni 'kuva' sisendina, mis väljastab loendi iga sõlme väärtuse algusest lõpuni.
- Aastal peamine funktsioon, luues silmuse.
- Funktsiooni 'functionHashMap' kutsutakse välja headNode'i osutiga sisendiks, mis eemaldab loendist tsükli.
- Muudetud loend kuvatakse funktsiooni 'kuva' abil.
2. lähenemine: Floydi tsükkel
Floydi tsüklituvastusalgoritm, mida sageli tuntakse kilpkonna ja jänese algoritmina, annab aluse sellele meetodile tsüklite lingitud loendis leidmiseks. Selles tehnikas kasutatakse kaks osutit 'aeglane' ja 'kiire' osuti, mis läbivad loendit erineva kiirusega. Kiire kursor liigub kaks sammu edasi, samas kui aeglane kursor liigub iga iteratsiooni ühe sammu võrra edasi. Lingitud loendis on tsükkel, kui need kaks punkti kunagi vastamisi puutuvad.
1. Lingitud loendi peasõlmega initsialiseerime kaks osutit, mida nimetatakse kiireks ja aeglaseks.
2. Nüüd käivitame lingitud loendis liikumiseks tsükli. Kiiret kursorit tuleks iga iteratsiooni sammul liigutada kaks kohta aeglase kursori ette.
3. Lingitud loendis ei teki tsüklit, kui kiirkursor jõuab loendi lõppu (fastPointer == NULL või fastPointer->next == NULL). Kui ei, siis kiired ja aeglased osutid kohtuvad lõpuks, mis tähendab, et lingitud loendil on silmus.
C++ programmi rakendamine ülaltoodud meetodi jaoks (Floydi tsükkel):
#include
kasutades nimeruumi std;
/* Linkide loendi sõlm */
struktuuri sõlm {
int andmed;
struktuuri sõlm * järgmine;
} ;
/* Funktsioon silmuse eemaldamiseks. */
tühine deleteLoop ( struktuuri sõlm * , struct Node * ) ;
/* See funktsiooni otsib ja kõrvaldab loendi silmuseid. See annab järele 1
kui seal oli silmus sisse nimekiri; muidu , see naaseb 0 . */
int detectAndDeleteLoop ( struktuuri sõlm * nimekirja )
{
struktuuri sõlm * aeglanePTR = loend, * fastPTR = loend;
// Korda kontrollimiseks kui silmus on olemas.
samal ajal ( aeglanePTR && kiire PTR && kiire PTR- > järgmiseks ) {
aeglanePTR = aeglanePTR- > järgmine;
fastPTR = kiire PTR- > järgmine- > järgmine;
/* Kui slowPTR ja fastPTR ühel hetkel kokku saavad siis seal
on silmus */
kui ( aeglanePTR == kiire PTR ) {
Kustuta Loop ( aeglanePTR, nimekiri ) ;
/* Tagasi 1 näitamaks, et silmus on avastatud. */
tagasi 1 ;
}
}
/* Tagasi 0 näitamaks, et silmust pole avastatud. */
tagasi 0 ;
}
/* Funktsioon silmuse kustutamiseks lingitud loendist.
loopNode osutab ühele silmussõlmedest ja headNode osutab
lingitud loendi algussõlme */
tühine deleteLoop ( struktuuri sõlm * loopNode, struct Node * peasõlm )
{
struktuuri sõlm * ptr1 = loopNode;
struktuuri sõlm * ptr2 = loopNode;
// Loendage, mitu sõlme on sisse silmus.
märgita int k = 1 , i;
samal ajal ( ptr1- > järgmiseks ! = ptr2 ) {
ptr1 = ptr1- > järgmine;
k++;
}
// Kinnitage üks kursor peasõlmele
ptr1 = peasõlm;
// Ja teine osuti k sõlme peale headNode
ptr2 = peasõlm;
jaoks ( i = 0 ; i < k; i++ )
ptr2 = ptr2- > järgmine;
/* Kui mõlemat punkti liigutatakse korraga,
nad põrkuvad silmuses kokku algussõlm. */
while (ptr2 != ptr1) {
ptr1 = ptr1->järgmine;
ptr2 = ptr2->järgmine;
}
// Hankige sõlm' s viimane osuti.
samal ajal ( ptr2- > järgmiseks ! = ptr1 )
ptr2 = ptr2- > järgmine;
/* Silmuse sulgemiseks seatud järgnev
silmuse sõlm 'i lõpetav sõlm. */
ptr2->järgmine = NULL;
}
/* Funktsioon lingitud loendi kuvamiseks */
void displayLinkedList(struct Node* node)
{
// kuvab lingitud loendi pärast tsükli kustutamist
while (sõlm != NULL) {
cout << sõlme->andmed << ' ';
sõlm = sõlm->järgmine;
}
}
struct Node* newNode(int-võti)
{
struct Node* temp = new Node();
temp->andmed = võti;
temp->järgmine = NULL;
tagasivoolu temp;
}
// Põhikood
int main()
{
struct Node* headNode = uusSõlm(48);
headNode->next = uusSõlm(18);
headSõlm->järgmine->järgmine = uusSõlm(13);
headSõlm->järgmine->järgmine->järgmine = uusSõlm(2);
headNode-> next-> next-> next-> next = newNode(8);
/* Loo silmus */
headNode-> next-> next-> next-> next-> next = headNode-> next-> next;
// kuvab tsükli lingitud loendis
//displayLinkedList(headNode);
tuvastajaKustutaLoop(peasõlm);
cout << 'Lingitud loend pärast tsükli puudumist \n';
kuvaLinkedList(headNode);
tagasi 0;
}
Väljund:
Lingitud loend pärast tsükli puudumist
48 18 13 2 8
Selgitus:
-
- Esmalt lisatakse asjakohased päised, nagu 'bits/stdc++.h' ja 'std::cout'.
- Seejärel deklareeritakse struktuur 'Sõlm', mis tähistab lingitud loendis olevat sõlme. Järgmine osuti, mis viib loendi järgmise sõlme juurde, on lisatud igasse sõlme koos täisarvulise andmeväljaga.
- Seejärel määratleb see kaks funktsiooni 'deleteLoop' ja 'detectAndDeleteLoop'. Silmus eemaldatakse lingitud loendist esimest meetodit kasutades ja tsükkel tuvastatakse loendis teise funktsiooni abil, mis seejärel kutsub esile esimese protseduuri silmuse eemaldamiseks.
- Põhifunktsioonis luuakse uus viie sõlmega lingitud loend ja silmus luuakse, määrates viimase sõlme järgmise osuti kolmandale sõlmele.
- Seejärel helistab see meetodile 'detectAndDeleteLoop', edastades argumendina lingitud loendi peasõlme. Silmuste tuvastamiseks kasutab see funktsioon 'aeglaste ja kiirete osutite' lähenemisviisi. See kasutab kahte osutit, mis algavad loendi ülaosas: slowPTR ja fastPTR. Kui kiire kursor liigutab kahte sõlme korraga, liigub aeglane osuti korraga ainult ühte sõlme. Kiire osuti möödub lõpuks aeglasest, kui loend sisaldab tsüklit ja kaks punkti põrkuvad samas sõlmes.
- Funktsioon kutsub tsükli leidmisel esile funktsiooni 'deleteLoop', pakkudes sisenditena loendi peasõlme ning aeglaste ja kiirete osutite ristumiskohta. See protseduur loob kaks osutit, ptr1 ja ptr2, loendi peasõlmele ja loendab sõlmede arvu ahelas. Pärast seda liigub see ühe kursori k sõlme võrra edasi, kus k on tsükli sõlmede koguarv. Seejärel, kuni nad tsükli alguses kohtuvad, liigub see mõlemas punktis ühe sõlme kaupa edasi. Seejärel tsükkel katkeb, seades tsükli lõpus oleva sõlme järgmise osuti väärtusele NULL.
- Pärast tsükli eemaldamist kuvab see viimase sammuna lingitud loendi.
3. lähenemisviis: rekursioon
Rekursioon on meetod probleemide lahendamiseks, jagades need väiksemateks ja lihtsamateks alamprobleemideks. Rekursiooni saab kasutada üksikult lingitud loendi läbimiseks juhul, kui tsükkel leitakse, käivitades pidevalt loendi järgmise sõlme funktsiooni kuni loendi lõpuni.
Üksiklingitud loendis on tsükli leidmiseks rekursiooni kasutamise põhiprintsiip alustada loendi algusest, märkida igas etapis praegune sõlm külastatuks ja seejärel minna järgmise sõlme juurde, käivitades rekursiivselt funktsiooni see sõlm. Meetod kordab kogu lingitud loendit, kuna seda kutsutakse rekursiivselt.
Loend sisaldab tsüklit, kui funktsioon kohtab sõlme, mis on eelnevalt märgitud külastatuks; sel juhul võib funktsioon tagastada tõene. Meetod võib tagastada vale, kui see jõuab loendi lõppu ilma külastatud sõlme läbimata, mis näitab, et silmust pole.
Kuigi seda meetodit rekursiooni kasutamiseks tsükli leidmiseks ühest lingitud loendist on lihtne kasutada ja mõista, ei pruugi see olla aja ja ruumi keerukuse mõttes kõige tõhusam.
C++ programmi rakendamine ülaltoodud meetodi jaoks (rekursioon):
#include
kasutades nimeruumi std;
struktuuri sõlm {
int andmed;
Sõlm * järgmine;
bool külastatud;
} ;
// Lingitud loendi silmuse tuvastamine funktsiooni
bool detectLoopLinkedList ( Sõlm * peasõlm ) {
kui ( headNode == NULL ) {
tagasi vale ; // Kui lingitud loend on tühi, siis põhiline juhtum
}
// Seal on silmus kui praegusel sõlmel on
// juba külastatud.
kui ( peasõlm- > külastanud ) {
tagasi tõsi ;
}
// Lisage praegusele sõlmele külastusmärk.
peasõlm- > külastatud = tõsi ;
// Koodi helistamine jaoks järgnev sõlm korduvalt
tagasi detectLoopLinkedList ( peasõlm- > järgmiseks ) ;
}
int main ( ) {
Sõlm * headNode = uus sõlm ( ) ;
Sõlm * secondNode = uus sõlm ( ) ;
Sõlm * thirdNode = uus sõlm ( ) ;
peasõlm- > andmed = 1 ;
peasõlm- > järgmine = teineNode;
peasõlm- > külastatud = vale ;
teine sõlm- > andmed = 2 ;
teine sõlm- > järgmine = kolmasSõlm;
teine sõlm- > külastatud = vale ;
kolmas sõlm- > andmed = 3 ;
kolmas sõlm- > järgmine = NULL; // Silmust pole
kolmas sõlm- > külastatud = vale ;
kui ( detectLoopLinkedList ( peasõlm ) ) {
cout << 'Lingitud loendis tuvastati silmus' << endl;
} muidu {
cout << 'Lingitud loendis ei tuvastatud silmust' << endl;
}
// Silmuse loomine
kolmas sõlm- > järgmine = teineNode;
kui ( detectLoopLinkedList ( peasõlm ) ) {
cout << 'Lingitud loendis tuvastati silmus' << endl;
} muidu {
cout << 'Lingitud loendis ei tuvastatud silmust' << endl;
}
tagasi 0 ;
}
Väljund:
Silmust ei tuvastatud sisse lingitud loend
Loop tuvastatud sisse lingitud loend
Selgitus:
-
- Funktsioon detectLoopLinkedList() selles programmis aktsepteerib sisendina lingitud loendi pea.
- Funktsioon kasutab rekursiooni lingitud loendi kordamiseks. Rekursiooni põhijuhtumina algab see määramisega, kas praegune sõlm on NULL. Kui jah, tagastab meetod vale, mis näitab, et silmust pole olemas.
- Seejärel kontrollitakse praeguse sõlme „külastatud” atribuudi väärtust, et näha, kas seda on varem külastatud. See tagastab tõene, kui seda on külastatud, mis viitab sellele, et silmus on leitud.
- Funktsioon märgib praeguse sõlme külastatuks, kui seda on juba külastatud, muutes selle 'külastatud' atribuudi tõeseks.
- Seejärel kontrollitakse külastatud muutuja väärtust, et näha, kas praegust sõlme on varem külastatud. Kui seda on varem kasutatud, peab tsükkel olemas olema ja funktsioon tagastab tõene.
- Lõpuks kutsub funktsioon end edasi andes välja loendi järgmise sõlmega headNode-> next argumendina. Rekursiivselt , tehakse seda seni, kuni leitakse silmus või kõik sõlmed on külastatud. Tähendab, funktsioon seab külastatud muutuja väärtuseks Tõene, kui praegust sõlme pole kunagi külastatud, enne kui rekursiivselt kutsub end lingitud loendis järgmise sõlme jaoks.
- Kood loob kolm sõlme ja ühendab need, et luua lingitud loend põhifunktsioon . Meetod detectLoopLinkedList() seejärel käivitatakse loendi peasõlmes. Programm toodab ' Lingitud loendis on silmus maha arvatud 'kui detectLoopLinkedList() tagastab tõene; muidu väljastab see ' Lingitud loendis silmust ei tuvastatud “.
- Seejärel lisab kood lingitud loendisse silmuse, määrates viimase sõlme järgmise kursori teisele sõlmele. Seejärel käivitatakse see sõltuvalt funktsiooni tulemusest detectLoopLinkedList() uuesti ja toodab kas ' Lingitud loendis on silmus maha arvatud ” või „ Lingitud loendis silmust ei tuvastatud .”
4. lähenemisviis: virna kasutamine
Lingitud loendis olevad tsüklid on leitavad virna ja DFS-meetodi abil. Põhikontseptsioon on lingitud loendi kordamine, lükates iga sõlme virna, kui seda pole veel külastatud. Silmus tuvastatakse, kui sõlm, mis on juba virnas, puutub uuesti kokku.
Siin on protseduuri lühikirjeldus:
-
- Looge külastatud sõlmede salvestamiseks tühi virn ja muutuja.
- Lükake lingitud loend virnale, alustades ülaosast. Pange tähele, et pea on külastatud.
- Lükake loendi järgmine sõlm virnale. Lisage sellele sõlmele külastusmärk.
- Loendi läbimisel lükake iga uus sõlm virnale, et näidata, et seda on külastatud.
- Kontrollige, kas varem külastatud sõlm asub virna ülaosas, kui seda kohtate. Kui jah, siis on silmus leitud ja silmus tuvastatakse virna sõlmede järgi.
- Tõstke sõlmed virnast välja ja jätkake loendi läbimist, kui tsüklit ei leita.
C++ programmi rakendamine ülaltoodud meetodi jaoks (stack)
#include
#include
kasutades nimeruumi std;
struktuuri sõlm {
int andmed;
Sõlm * järgmine;
} ;
// Funktsioon silmuse tuvastamiseks sisse lingitud loend
bool detectLoopLinkedList ( Sõlm * peasõlm ) {
virna < Sõlm *> virna;
Sõlm * tempNode = headNode;
samal ajal ( tempNode ! = NULL ) {
// kui virna ülemine element sobib
// praegune sõlm ja virn ei ole tühi
kui ( ! virn.tühi ( ) && virna.top ( ) == tempNode ) {
tagasi tõsi ;
}
stack.push ( tempNode ) ;
tempNode = tempNode- > järgmine;
}
tagasi vale ;
}
int main ( ) {
Sõlm * headNode = uus sõlm ( ) ;
Sõlm * secondNode = uus sõlm ( ) ;
Sõlm * thirdNode = uus sõlm ( ) ;
peasõlm- > andmed = 1 ;
peasõlm- > järgmine = teineNode;
teine sõlm- > andmed = 2 ;
teine sõlm- > järgmine = kolmasSõlm;
kolmas sõlm- > andmed = 3 ;
kolmas sõlm- > järgmine = NULL; // Silmust pole
kui ( detectLoopLinkedList ( peasõlm ) ) {
cout << 'Lingitud loendis tuvastati silmus' << endl;
} muidu {
cout << 'Lingitud loendis ei tuvastatud silmust' << endl;
}
// Silmuse loomine
kolmas sõlm- > järgmine = teineNode;
kui ( detectLoopLinkedList ( peasõlm ) ) {
cout << 'Lingitud loendis tuvastati silmus' << endl;
} muidu {
cout << 'Lingitud loendis ei tuvastatud silmust' << endl;
}
Väljund:
Silmust ei tuvastatud sisse lingitud loend
Loop tuvastatud sisse lingitud loend
Selgitus:
See programm kasutab virna, et teada saada, kas üksikult lingitud loendil on silmus.
- 1. Sisend-/väljundvooteek ja viru teek on mõlemad esimesel real.
2. Standardne nimeruum sisaldub teisel real, mis võimaldab meil pääseda juurde sisend-/väljundvoo teegi funktsioonidele, ilma et peaksime nende eesliidet lisama 'std::'.
3. Järgmine rida määratleb struktuurisõlme, mis koosneb kahest liikmest: täisarv nimega 'data' ja osuti teisele sõlmele, mida nimetatakse 'järgmiseks'.
4. Lingitud loendi pea on sisend meetodile detectLoopLinkedList(), mis on määratletud järgmisel real. Funktsioon loob tõeväärtuse, mis näitab, kas silmus leiti või mitte.
5. Funktsiooni sees luuakse nii sõlmede vihjete virn, mida nimetatakse virnaks, kui ka osuti sõlmele nimega tempNode, mis on initsialiseeritud headNode'i väärtusega.
6. Kui tempNode ei ole null osuti, sisestame while-tsükli.
(a) Virna ülemine element peab ühtima praeguse sõlmega, et saaksime kindlaks teha, et see pole tühi. Kui see on nii, tagastame tõese, kuna tsükkel on leitud.
(b) Kui eelnimetatud tingimus on väär, lükatakse praeguse sõlme osuti virnale ja tempNode seatakse lingitud loendis järgmisele sõlmele.
7. Pärast while-tsüklit tagastame vale, kuna tsüklit ei täheldatud.
8. Ehitame kolm sõlmeobjekti ja initsialiseerime need funktsioonis main(). Kuna esimeses näites silmust pole, seadsime iga sõlme 'järgmised' osutid õigesti.
Järeldus:
Kokkuvõtteks võib öelda, et parim meetod lingitud loendis olevate silmuste tuvastamiseks sõltub konkreetsest kasutusjuhtumist ja probleemi piirangutest. Hash Table ja Floydi tsükliotsingu algoritm on tõhusad meetodid ja neid kasutatakse praktikas laialdaselt. Virn ja rekursioon on vähem tõhusad meetodid, kuid need on intuitiivsemad.