Mikä on Circular linkitetty luettelo?

The pyöreä linkitetty luettelo on linkitetty luettelo, jossa kaikki solmut on yhdistetty muodostamaan ympyrän. Ympyränmuotoisessa linkitetyssä luettelossa ensimmäinen solmu ja viimeinen solmu ovat yhteydessä toisiinsa, mikä muodostaa ympyrän. Lopussa ei ole NULL-merkkiä.

Pyöreä linkitetty luettelo

Pyöreitä linkitettyjä luetteloita on yleensä kahdenlaisia:

• Pyöreä yksittäin linkitetty luettelo: Ympyränmuotoisessa Yksittäin linkitetyssä luettelossa luettelon viimeinen solmu sisältää osoittimen luettelon ensimmäiseen solmuun. Kuljemme pyöreän yksitellen linkitetyn luettelon läpi, kunnes saavutamme saman solmun, josta aloitimme. Pyöreällä yksittäin linkitetyllä luettelolla ei ole alkua tai loppua. Minkään solmun seuraavassa osassa ei ole nolla-arvoa.

Edustus Circular yksittäin linkitetty luettelo

staattinen toiminto javassa

• Pyöreä kaksoislinkitetty luettelo: Circular Double Linked List -luettelossa on sekä kaksoislinkitetyn luettelon että ympyrälinkitetun luettelon ominaisuuksia, joissa kaksi peräkkäistä elementtiä on linkitetty tai yhdistetty edellisellä ja seuraavalla osoittimella ja viimeinen solmu osoittaa ensimmäiseen solmuun seuraavan osoittimen avulla ja myös ensimmäinen solmu osoittaa edellisen osoittimen viimeinen solmu.

Pyöreän kaksoislinkitetyn luettelon esitys

Huomautus: Käytämme yksittäin pyöreää linkitettyä luetteloa edustamaan pyöreän linkitetyn luettelon toimintaa.

Pyöreän linkitetyn luettelon esitys:

Pyöreät linkitetyt luettelot ovat samanlaisia ​​kuin yksittäiset linkitetyt luettelot, paitsi että viimeinen solmu yhdistetään ensimmäiseen solmuun.

Pyöreän linkitetyn luettelon solmuesitys:

// Class Node, similar to the linked list class Node{  int value; // Points to the next node.  Node next; }>

struct Node {  int data;  struct Node *next; };>

public class Node {  int data;  Node next;    public Node(int data) {  this.data = data;  this.next = null;  } }>

public class Node {  public int data;  public Node next;    public Node(int data)  {  this.data = data;  this.next = null;  } }>

class Node {  constructor(data) {  this.data = data;  this.next = null;  } }>

class Node {  public $data;  public $next;  function __construct($data) {  $this->data = $data;  $tämä->seuraava = null;  } }>

# Class Node, similar to the linked list class Node: def __init__(self,data): self.data = data self.next = None>

Esimerkki kiertokirjeestä erikseen linkitetystä luettelosta:

Esimerkki pyöreästä linkitetystä luettelosta

Yllä oleva kiertokirje yksittäin linkitetty luettelo voidaan esittää seuraavasti:

// Initialize the Nodes. Node one = new Node(3); Node two = new Node(5); Node three = new Node(9); // Connect nodes one.next = two; two.next = three; three.next = one;>

Node* one = createNode(3); Node* two = createNode(5); Node* three = createNode(9); // Connect nodes one->seuraava = kaksi; kaksi->seuraava = kolme; kolme->seuraava = yksi;>>Java 
Node one = new Node(3); Node two = new Node(5); Node three = new Node(9); // Connect nodes one.next = two; two.next = three; three.next = one;>
 Javascript 
let one = new Node(3); let two = new Node(5); let three = new Node(9); // Connect nodes one.next = two; two.next = three; three.next = one;>
 PHP 
$one = new Node(3); $two = new Node(5); $three = new Node(9); // Connect nodes $one->seuraava = $kaksi; $kaksi->seuraava = $kolme; $kolme->seuraava = $yksi;>>Python 3    Selitys:    Yllä olevassa ohjelmassa yksi, kaksi ja kolme ovat solmu arvoilla 3, 5 ja 9, jotka on yhdistetty ympyrämäisesti seuraavasti:
 
    Node One:    Seuraava-osoitin tallentaa solmun kaksi osoitteen.
    Solmulle kaksi:    Seuraava tallentaa solmun kolme osoitteen
    Solmulle kolme:    The         Seuraava osoittaa solmuun yksi.
Pyöreän linkitetyn luettelon toiminnot:
Voimme tehdä pyöreällä linkitetyllä luettelolla joitain toimintoja, jotka ovat samankaltaisia ​​kuin yksittäislinkitetty luettelo, jotka ovat:
 
Lisäys
Poistaminen
1. Lisäys linkitettyyn pyöreään luetteloon: 
Solmu voidaan lisätä kolmella tavalla:
 
Lisäys luettelon alkuun
Lisäys luettelon loppuun
Asennus solmujen väliin
1)    Lisäys listan alkuun:    Voit lisätä solmun luettelon alkuun seuraavasti:
 
Luo solmu, sano T.
Tee T -> seuraava = viimeinen -> seuraava.
viimeinen -> seuraava = T.
  
Pyöreä linkitetty luettelo ennen lisäystä
 
Ja sitten,
  
Pyöreä linkitetty luettelo lisäyksen jälkeen
 
2)    Lisäys listan loppuun:    Voit lisätä solmun luettelon loppuun seuraavasti:
 
Luo solmu, sano T.
Tee T -> seuraava = viimeinen -> seuraava;
viimeinen -> seuraava = T.
viimeinen = T.
Ennen asettamista,
  
Pyöreä linkitetty luettelo ennen solmun lisäämistä loppuun
 
asettamisen jälkeen,
  
Pyöreä linkitetty luettelo solmun lisäyksen jälkeen
 
3)    Lisäys solmujen väliin:    Voit lisätä solmun kahden solmun väliin seuraavasti:
 
Luo solmu, sano T.
Etsi solmu, jonka jälkeen T on lisättävä, sano, että solmu on P.
Tee T -> seuraava = P -> seuraava;
P -> seuraava = T.
Oletetaan, että 12 on lisättävä sen jälkeen, kun solmun arvo on 10,
  
Pyöreä linkitetty luettelo ennen lisäystä
 
Haun ja lisäyksen jälkeen
  
Pyöreä linkitetty luettelo lisäyksen jälkeen
 
2. Poistaminen linkitetystä luettelosta:
    1) Poista solmu vain, jos se on pyöreän linkitetyn luettelon ainoa solmu:    
 
Vapauta solmun muisti
Viimeisen arvon tulee olla NULL. Solmu osoittaa aina toiseen solmuun, joten NULL-määritystä ei tarvita.  
Mikä tahansa solmu voidaan asettaa aloituspisteeksi.  
Solmut kulkevat nopeasti ensimmäisestä viimeiseen.
    2) Viimeisen solmun poistaminen:    
 
Paikanna solmu ennen viimeistä solmua (olkoon sen lämpötila)
Pidä solmun osoite viimeisen solmun vieressä temp
Poista viimeinen muisti
Laita lämpötila loppuun
    3) Poista mikä tahansa solmu pyöreästä linkitetystä luettelosta:    Meille annetaan solmu ja tehtävämme on poistaa kyseinen solmu pyöreästä linkitetystä luettelosta.
 
    Algoritmi:     
    Tapaus 1    : Lista on tyhjä.
 
Jos lista on tyhjä, palaamme takaisin.
    Tapaus 2    :Lista ei ole tyhjä
 
Jos luettelo ei ole tyhjä, määritämme kaksi osoitinta    curr    ja    Ed    ja alusta osoitin    curr    kanssa    pää    solmu.
Selaa luetteloa käyttämällä    curr    löytääksesi poistettavan solmun ja ennen kuin siirryt curriin seuraavaan solmuun, aseta joka kerta prev = curr.
Jos solmu löytyy, tarkista, onko se luettelon ainoa solmu. Jos kyllä, aseta head = NULL ja free(curr).
Jos luettelossa on useampi kuin yksi solmu, tarkista, onko se luettelon ensimmäinen solmu. Edellytys tämän tarkistamiseksi (curr == pää). Jos kyllä, siirry edelliseen, kunnes se saavuttaa viimeisen solmun. Kun edellinen saavuttaa viimeisen solmun, aseta head = head -> next ja prev -> next = head. Poista curr.
Jos curr ei ole ensimmäinen solmu, tarkistamme, onko se luettelon viimeinen solmu. Tämän tarkistamisen ehto on (curr -> next == head).
Jos curr on viimeinen solmu. Aseta edellinen -> seuraava = head ja poista solmu curr arvolla free(curr).
Jos poistettava solmu ei ole ensimmäinen eikä viimeinen solmu, aseta prev -> next = curr -> next ja poista curr.
Jos solmua ei ole luettelossa, palauta pää äläkä tee mitään.
Alla on yllä olevan lähestymistavan toteutus:
C++ 
// C++ program to delete a given key from // linked list. #include  using namespace std; // Structure for a node class Node { public:  int data;  Node* next; }; // Function to insert a node at the // beginning of a Circular linked list void push(Node** head_ref, int data) {  // Create a new node and make head  // as next of it.  Node* ptr1 = new Node();  ptr1->data = data;  ptr1->seuraava = *head_ref;  // Jos linkitetty lista ei ole NULL, // aseta viimeisen solmun seuraava if (*head_ref != NULL) { // Etsi solmu ennen head ja // päivitä sen jälkeen.  Solmu* temp = *head_ref;  while (lämpö->seuraava != *head_ref) temp = temp->seuraava;  temp->seuraava = ptr1;  } else // Ensimmäiselle solmulle ptr1->seuraava = ptr1;  *head_ref = ptr1; } // Toiminto tietyn solmujen tulostamiseksi // pyöreä linkitetty lista void printList(Solmu* head) { Node* temp = head;  if (head != NULL) { do { cout<< temp->tiedot<< ' ';  temp = temp->Seuraava;  } while (lämpö != pää);  } cout<< endl; } // Function to delete a given node // from the list void deleteNode(Node** head, int key) {  // If linked list is empty  if (*head == NULL)  return;  // If the list contains only a  // single node  if ((*head)->data == avain && (*pää)->seuraava == *pää) { vapaa(*pää);  *pää = NULL;  palata;  } Solmu *viimeinen = *pää, *d;  // Jos pää poistetaan if ((*head)->data == avain) { // Etsi luettelon viimeinen solmu while (viimeinen->seuraava != *head) last = viimeinen->seuraava;  // Osoita viimeinen solmu // pään seuraavaan eli listan toiseen solmuun // viimeinen->seuraava = (*head)->seuraava;  vapaa(*pää);  *pää = viimeinen->seuraava;  palata;  } // Joko poistettavaa solmua // ei löydy tai listan // loppua ei ole saavutettu while (viimeinen->seuraava != *head && viimeinen->seuraava->tiedot != avain) { viimeinen = viimeinen ->seuraava;  } // Jos poistettava solmu löytyi if (viimeinen->seuraava->data == avain) { d = viimeinen->seuraava;  viimeinen->seuraava = d->seuraava;  vapaa(d);  } else cout<< 'Given node is not found in the list!!!
'; } // Driver code int main() {  // Initialize lists as empty  Node* head = NULL;  // Created linked list will be  // 2->5->7->8->10 push(&head, 2);  push(&head, 5);  push(&head, 7);  push(&head, 8);  push(&head, 10);  cout<< 'List Before Deletion: ';  printList(head);  deleteNode(&head, 7);  cout << 'List After Deletion: ';  printList(head);  return 0; }>
 C 
#include  #include  // Structure for a node struct Node {  int data;  struct Node* next; }; // Function to insert a node at the // beginning of a Circular linked list void push(struct Node** head_ref, int data) {  // Create a new node and make head  // as next of it.  struct Node* ptr1 = (struct Node*)malloc(sizeof(struct Node));  ptr1->data = data;  ptr1->seuraava = *head_ref;  // Jos linkitetty lista ei ole NULL, // aseta viimeisen solmun seuraava if (*head_ref != NULL) { // Etsi solmu ennen head ja // päivitä sen jälkeen.  struct Node* temp = *head_ref;  while (lämpö->seuraava != *head_ref) temp = temp->seuraava;  temp->seuraava = ptr1;  } else // Ensimmäiselle solmulle ptr1->seuraava = ptr1;  *head_ref = ptr1; } // Toiminto tietyn solmujen tulostamiseksi // pyöreä linkitetty lista void printList(struct Node* head) { struct Node* temp = head;  if (head != NULL) { do { printf('%d ', temp-> data);  temp = lämpötila->seuraava;  } while (lämpö != pää);  } printf('
'); } // Toiminto tietyn solmun poistamiseksi // listasta void deleteNode(struct Node** head, int key) { // Jos linkitetty lista on tyhjä if (*head == NULL) return;  // Jos lista sisältää vain // yhden solmun if ((*head)->data == avain && (*head)->seuraava == *head) { vapaa(*pää);  *pää = NULL;  palata;  } struct Solmu *last = *head, *d;  // Jos pää poistetaan if ((*head)->data == avain) { // Etsi luettelon viimeinen solmu while (viimeinen->seuraava != *head) last = viimeinen->seuraava;  // Osoita viimeinen solmu // pään seuraavaan eli listan toiseen solmuun // viimeinen->seuraava = (*head)->seuraava;  vapaa(*pää);  *pää = viimeinen->seuraava;  palata;  } // Joko poistettavaa solmua // ei löydy tai listan // loppua ei saavuteta while (viimeinen->seuraava != *head && viime->seuraava->tiedot != avain) { viimeinen = viimeinen ->seuraava;  } // Jos poistettava solmu löytyi if (viimeinen->seuraava->data == avain) { d = viimeinen->seuraava;  viimeinen->seuraava = d->seuraava;  vapaa(d);  } else printf('Tietyttyä solmua ei löydy listasta!!!
'); } // Ohjainkoodi int main() { // Alusta luettelot tyhjiksi rakenteiksi Solmu* head = NULL;  // Luotu linkitetty lista on // 2->5->7->8->10 push(&head, 2);  push(&head, 5);  push(&head, 7);  push(&head, 8);  push(&head, 10);  printf('Lista ennen poistoa: ');  printList(head);  deleteNode(&head, 7);  printf('Lista poiston jälkeen: ');  printList(head);  paluu 0; }>
 Java 
// Java program to delete a given key from // linked list. import java.io.*; import java.util.*; public class GFG {  /* structure for a node */  static class Node {  int data;  Node next;  };  /* Function to insert a node at the beginning of a Circular linked list */  static Node push(Node head_ref, int data)  {  // Create a new node and make head as next  // of it.  Node ptr1 = new Node();  ptr1.data = data;  ptr1.next = head_ref;  /* If linked list is not null then set the next of last node */  if (head_ref != null) {  // Find the node before head and update  // next of it.  Node temp = head_ref;  while (temp.next != head_ref)  temp = temp.next;  temp.next = ptr1;  }  else  ptr1.next = ptr1; /*For the first node */  head_ref = ptr1;  return head_ref;  }  /* Function to print nodes in a given circular linked list */  static void printList(Node head)  {  Node temp = head;  if (head != null) {  do {  System.out.printf('%d ', temp.data);  temp = temp.next;  } while (temp != head);  }  System.out.printf('
');  }  /* Function to delete a given node from the list */  static Node deleteNode(Node head, int key)  {  if (head == null)  return null;  int flag = 0;  // Find the required node  Node curr = head, prev = new Node();  while (curr.data != key) {  if (curr.next == head) {  System.out.printf(  'Given node is not found in the list!!!
');  flag = 1;  break;  }  prev = curr;  curr = curr.next;  }  // Check if the element is not present in the list  if (flag == 1)  return head;  // Check if node is only node  if (curr == head && curr.next == head) {  head = null;  return head;  }  // If more than one node, check if  // it is first node  if (curr == head) {  prev = head;  while (prev.next != head)  prev = prev.next;  head = curr.next;  prev.next = head;  }  // check if node is last node  else if (curr.next == head) {  prev.next = head;  }  else {  prev.next = curr.next;  }  return head;  }  /* Driver code */  public static void main(String args[])  {  /* Initialize lists as empty */  Node head = null;  /* Created linked list will be 2.5.7.8.10 */  head = push(head, 2);  head = push(head, 5);  head = push(head, 7);  head = push(head, 8);  head = push(head, 10);  System.out.printf('List Before Deletion: ');  printList(head);  head = deleteNode(head, 7);  System.out.printf('List After Deletion: ');  printList(head);  } } // This code is contributed by Susobhan Akhuli>
 C# 
using System; // Structure for a node public class Node {  public int data;  public Node next; } // Class for Circular Linked List public class CircularLinkedList {  // Function to insert a node at the  // beginning of a Circular linked list  public static void Push(ref Node head_ref, int data)  {  // Create a new node and make head  // as next of it.  Node ptr1 = new Node();  ptr1.data = data;  ptr1.next = head_ref;  // If linked list is not NULL then  // set the next of last node  if (head_ref != null) {  // Find the node before head and  // update next of it.  Node temp = head_ref;  while (temp.next != head_ref)  temp = temp.next;  temp.next = ptr1;  }  else  // For the first node  ptr1.next = ptr1;  head_ref = ptr1;  }  // Function to print nodes in a given  // circular linked list  public static void PrintList(Node head)  {  Node temp = head;  if (head != null) {  do {  Console.Write(temp.data + ' ');  temp = temp.next;  } while (temp != head);  }  Console.WriteLine();  }  // Function to delete a given node  // from the list  public static void DeleteNode(ref Node head, int key)  {  // If linked list is empty  if (head == null)  return;  // If the list contains only a  // single node  if (head.data == key && head.next == head) {  head = null;  return;  }  Node last = head, d;  // If head is to be deleted  if (head.data == key) {  // Find the last node of the list  while (last.next != head)  last = last.next;  // Point last node to the next of  // head i.e. the second node  // of the list  last.next = head.next;  head = last.next;  return;  }  // Either the node to be deleted is  // not found or the end of list  // is not reached  while (last.next != head && last.next.data != key) {  last = last.next;  }  // If node to be deleted was found  if (last.next.data == key) {  d = last.next;  last.next = d.next;  }  else  Console.WriteLine(  'Given node is not found in the list!!!');  }  // Driver code  public static void Main()  {  // Initialize lists as empty  Node head = null;  // Created linked list will be  // 2->5->7->8->10 Työntö (viitepää, 2);  Push(viitepää, 5);  Työntö (viitepää, 7);  Työntö (viitepää, 8);  Push(viitepää, 10);  Console.Write('Lista ennen poistoa: ');  TulostaLista(pää);  DeleteNode(ref head, 7);  Console.Write('Lista poiston jälkeen: ');  TulostaLista(pää);  } }>
 Javascript 
 // Javascript program to delete a given key from linked list.  // Structure for a node  class Node {  constructor() {  this.data;  this.next;  }  }  // Function to insert a node at the  // beginning of a Circular linked list  function push(head, data) {  // Create a new node and make head  // as next of it.  var ptr1 = new Node();  ptr1.data = data;  ptr1.next = head;  // If linked list is not NULL then  // set the next of last node  if (head != null) {  // Find the node before head and  // update next of it.  let temp = head;  while (temp.next != head) temp = temp.next;  temp.next = ptr1;  }  // For the first node  else ptr1.next = ptr1;  head = ptr1;  return head;  }  // Function to print nodes in a given  // circular linked list  function printList(head) {  let tempp = head;  if (head != null) {  do {  console.log(tempp.data);  tempp = tempp.next;  } while (tempp != head);  }  }  // Function to delete a given node  // from the list  function deleteNode(head, key) {  // If linked list is empty  if (head == null) return;  // If the list contains only a  // single node  if (head.data == key && head.next == head) {  head = null;  return;  }  let last = head;  // If head is to be deleted  if (head.data == key) {  // Find the last node of the list  while (last.next != head) last = last.next;  // Point last node to the next of  // head i.e. the second node  // of the list  last.next = head.next;  head = last.next;  return;  }  // Either the node to be deleted is  // not found or the end of list  // is not reached  while (last.next != head && last.next.data != key) {  last = last.next;  }  // If node to be deleted was found  if (last.next.data == key) {  d = last.next;  last.next = d.next;  d = null;  } else console.log('Given node is not found in the list!!!');  }  // Driver code  // Initialize lists as empty  head = null;  // Created linked list will be  // 2->5->7->8->10 pää = push(pää, 2);  pää = push(pää, 5);  pää = työnnä(pää, 7);  pää = työnnä(pää, 8);  pää = push(pää, 10);  console.log('Lista ennen poistoa: ');  printList(head);  deleteNode(head, 7);  console.log('Lista poiston jälkeen: ');  printList(head);>>Python 35->7->8->10 päätä = työnnä(pää, 2) pää = työnnä(pää, 5) pää = työnnä(pää, 7) pää = työnnä(pää, 8) pää = työnnä(pää, 10) print('Lista ennen poistoa: ') printList(head) deleteSolmu(pää, 7) print('Lista poiston jälkeen: ') printList(head)>
   
  Lähtö  
List Before Deletion: 10 8 7 5 2 List After Deletion: 10 8 5 2>
 
    Aika monimutkaisuus:    O(N), Pahin tapaus tapahtuu, kun poistettava elementti on viimeinen elementti ja joudumme liikkumaan koko listan läpi.  
    Aputila:    O(1), Vakiona lisätilaa käytetään.
 
    Pyöreän linkitetyn luettelon edut:     
Mikä tahansa solmu voi olla lähtökohta. Voimme käydä läpi koko listan aloittamalla mistä tahansa pisteestä. Meidän täytyy vain pysähtyä, kun ensimmäisellä vieraillulla solmulla vieraillaan uudelleen.
Hyödyllinen jonon toteuttamiseen. Toisin kuin Tämä toteutuksessa, meidän ei tarvitse ylläpitää kahta osoitinta edessä ja takana, jos käytämme pyöreää linkitettyä luetteloa. Voimme säilyttää osoittimen viimeiseen lisättyyn solmuun ja etuosa voidaan aina saada viimeiseksi seuraavana.
Pyöreät luettelot ovat hyödyllisiä sovelluksissa, kun listaa kiertää toistuvasti. Esimerkiksi, kun tietokoneessa on käynnissä useita sovelluksia, on tavallista, että käyttöjärjestelmä laittaa käynnissä olevat sovellukset luetteloon ja selaa niitä sitten läpi, jolloin kullekin annetaan siivu aikaa suoriutua ja saa ne sitten odottamaan. CPU annetaan toiselle sovellukselle. Käyttöjärjestelmän on kätevää käyttää pyöreää listaa, jotta se pääsee luettelon loppuun mennessään kiertämään luettelon etupuolelle.
Pyöreitä kaksoislinkitettyjä listoja käytetään edistyneiden tietorakenteiden toteuttamiseen, kuten  Fibonacci Kasa  .
Ympyränmuotoisen linkitetyn luettelon toteuttaminen voi olla suhteellisen helppoa verrattuna muihin monimutkaisempiin tietorakenteisiin, kuten puihin tai kaavioihin.
Pyöreän linkitetyn luettelon haitat:
Yksittäin linkitettyihin luetteloihin verrattuna pyöreät luettelot ovat monimutkaisempia.
Pyöreän listan kääntäminen käänteiseksi on monimutkaisempaa kuin pyöreän listan kääntäminen yksittäin tai kahdesti.
Koodi voi mennä äärettömään silmukkaan, jos sitä ei käsitellä huolellisesti.
Listan lopun löytäminen ja silmukan hallitseminen on vaikeampaa.
Vaikka pyöreät linkitetyt listat voivat olla tehokkaita tietyissä sovelluksissa, niiden suorituskyky voi olla hitaampaa kuin muut tietorakenteet tietyissä tapauksissa, kuten silloin, kun luetteloa täytyy lajitella tai etsiä.
Pyöreät linkitetyt luettelot eivät tarjoa suoraa pääsyä yksittäisiin solmuihin
Pyöreän linkitetyn luettelon sovellukset:
Moninpelit käyttävät tätä antaakseen jokaiselle pelaajalle mahdollisuuden pelata.
Pyöreän linkitetyn luettelon avulla voidaan järjestää useita käynnissä olevia sovelluksia käyttöjärjestelmässä. Käyttöjärjestelmä toistaa nämä sovellukset.
Pyöreitä linkitettyjä listoja voidaan käyttää resurssien allokointiongelmissa.
Pyöreitä linkitettyjä listoja käytetään yleisesti pyöreiden puskureiden toteuttamiseen,
Pyöreitä linkitettyjä listoja voidaan käyttää simulaatiossa ja pelaamisessa.
Miksi pyöreä linkitetty luettelo?
Solmu osoittaa aina toiseen solmuun, joten NULL-määritystä ei tarvita.
Mikä tahansa solmu voidaan asettaa aloituspisteeksi.
Solmut kulkevat nopeasti ensimmäisestä viimeiseen.
    Seuraavat viestit:        Pyöreä linkitetty luettelo | Sarja 2 (läpikulku)           Pyöreä yksittäinen linkitetty luettelo | Lisäys     Kirjoita kommentteja, jos löydät virheen yllä olevasta koodista/algoritmista tai löydä muita tapoja ratkaista sama ongelma