logo

TechCodeview

Úvod do kruhového prepojeného zoznamu

Čo je kruhový prepojený zoznam?

The kruhový prepojený zoznam je prepojený zoznam, kde sú všetky uzly spojené do kruhu. V kruhovom prepojenom zozname sú prvý uzol a posledný uzol navzájom spojené, čo tvorí kruh. Na konci nie je NULL.

Kruhový prepojený zoznam



Vo všeobecnosti existujú dva typy kruhových prepojených zoznamov:

  • Kruhový jednotlivo prepojený zoznam: V kruhovom jednoducho prepojenom zozname obsahuje posledný uzol zoznamu ukazovateľ na prvý uzol zoznamu. Prechádzame kruhovým jednotlivo prepojeným zoznamom, kým nedosiahneme rovnaký uzol, kde sme začali. Kruhový jednotlivo prepojený zoznam nemá začiatok ani koniec. V ďalšej časti žiadneho z uzlov nie je prítomná žiadna nulová hodnota.

Reprezentácia obežníka s jednoduchým prepojením

  • Kruhový dvojito prepojený zoznam: Kruhový dvojito prepojený zoznam má vlastnosti dvojito prepojeného zoznamu aj kruhového prepojeného zoznamu, v ktorom sú dva po sebe idúce prvky prepojené alebo spojené predchádzajúcim a nasledujúcim ukazovateľom a posledný uzol ukazuje na prvý uzol nasledujúcim ukazovateľom a tiež prvý uzol ukazuje na posledný uzol predchádzajúcim ukazovateľom.

Reprezentácia kruhového dvojito prepojeného zoznamu



Poznámka: Na znázornenie fungovania kruhového prepojeného zoznamu budeme používať jednoduchý kruhový prepojený zoznam.

Reprezentácia kruhového prepojeného zoznamu:

Kruhové prepojené zoznamy sú podobné ako jednotlivé prepojené zoznamy s výnimkou spojenia posledného uzla s prvým uzlom.

Reprezentácia uzla kruhového prepojeného zoznamu:



C++ 
// Class Node, similar to the linked list class Node{  int value; // Points to the next node.  Node next; }>
C 
struct Node {  int data;  struct Node *next; };>
Java 
public class Node {  int data;  Node next;    public Node(int data) {  this.data = data;  this.next = null;  } }>
C# 
public class Node {  public int data;  public Node next;    public Node(int data)  {  this.data = data;  this.next = null;  } }>
Javascript 
class Node {  constructor(data) {  this.data = data;  this.next = null;  } }>
PHP 
class Node {  public $data;  public $next;  function __construct($data) {  $this->data = $data;  $this->next = null;  } }>
Python3 
# Class Node, similar to the linked list class Node: def __init__(self,data): self.data = data self.next = None>

Príklad kruhového zoznamu s jedným odkazom:

Príklad kruhového prepojeného zoznamu

Vyššie uvedený kruhový jednotlivo prepojený zoznam môže byť reprezentovaný ako:

C++ 
// 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;>
C 
Node* one = createNode(3); Node* two = createNode(5); Node* three = createNode(9); // Connect nodes one->ďalší = dva; dva->ďalšie = tri; tri->ďalšie = jedna;>
Java 
// Define the Node class class Node {  int value;  Node next;  public Node(int value) {  this.value = value;  } } // 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;>
C# 
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->dalsi = $dva; $dva->ďalšie = $tri; $tri->ďalší = $jeden;>
Python3 
# Initialize the Nodes. one = Node(3) two = Node(5) three = Node(9) # Connect nodes one.next = two two.next = three three.next = one>

Vysvetlenie: Vo vyššie uvedenom programe sú jeden, dva a tri uzol s hodnotami 3, 5 a 9, ktoré sú spojené kruhovým spôsobom ako:

príkaz java if
  • Pre prvý uzol: Ukazovateľ Next ukladá adresu Uzla dva.
  • Pre Uzol 2: Ďalší ukladá adresu uzla tri
  • Pre uzol tri: The Ďalej ukazuje na prvý uzol.

Operácie na kruhovom prepojenom zozname:

Na kruhovom prepojenom zozname môžeme vykonávať niektoré operácie podobné jednoducho prepojenému zoznamu, a to:

  1. Vkladanie
  2. Vymazanie

1. Vloženie do kruhového prepojeného zoznamu:

Uzol je možné pridať tromi spôsobmi:

  1. Vloženie na začiatok zoznamu
  2. Vloženie na koniec zoznamu
  3. Vloženie medzi uzly

1) Vloženie na začiatok zoznamu: Ak chcete vložiť uzol na začiatok zoznamu, postupujte takto:

  • Vytvorte uzol, povedzte T.
  • Urobte T -> ďalší = posledný -> ďalší.
  • posledný -> ďalší = T.

Kruhový prepojený zoznam pred vložením

A potom,

Kruhový prepojený zoznam po vložení

2) Vloženie na koniec zoznamu: Ak chcete vložiť uzol na koniec zoznamu, postupujte takto:

  • Vytvorte uzol, povedzte T.
  • Make T -> next = last -> next;
  • posledný -> ďalší = T.
  • posledný = T.

Pred vložením,

Kruhový prepojený zoznam pred vložením uzla na koniec

Po vložení,

Kruhový prepojený zoznam po vložení uzla na koniec

3) Vloženie medzi uzly: Ak chcete vložiť uzol medzi dva uzly, postupujte takto:

  • Vytvorte uzol, povedzte T.
  • Vyhľadajte uzol, za ktorý je potrebné vložiť T, povedzme, že uzol je P.
  • Make T -> next = P -> next;
  • P -> ďalší = T.

Predpokladajme, že je potrebné vložiť 12 za uzol s hodnotou 10,

Kruhový prepojený zoznam pred vložením

Po vyhľadaní a vložení,

Kruhový prepojený zoznam po vložení

2. Odstránenie v kruhovom prepojenom zozname:

1) Odstráňte uzol iba vtedy, ak je to jediný uzol v kruhovom prepojenom zozname:

  • Uvoľnite pamäť uzla
  • Posledná hodnota by mala byť NULL Uzol vždy ukazuje na iný uzol, takže priradenie NULL nie je potrebné.
    Ako počiatočný bod možno nastaviť ľubovoľný uzol.
    Uzly sa prechádzajú rýchlo od prvého po posledný.

2) Odstránenie posledného uzla:

  • Nájdite uzol pred posledným uzlom (nech je to teplota)
  • Ponechajte adresu uzla vedľa posledného uzla v temp
  • Vymažte poslednú pamäť
  • Dajte teplotu na koniec

3) Odstráňte akýkoľvek uzol z kruhového prepojeného zoznamu: Dostaneme uzol a našou úlohou je odstrániť tento uzol z kruhového prepojeného zoznamu.

Algoritmus:
Prípad 1 : Zoznam je prázdny.

  • Ak je zoznam prázdny, jednoducho sa vrátime.

Prípad 2 :Zoznam nie je prázdny

  • Ak zoznam nie je prázdny, definujeme dva ukazovatele curr a predch a inicializujte ukazovateľ curr s hlavu uzol.
  • Prechádzajte zoznamom pomocou curr na nájdenie uzla, ktorý sa má vymazať, a pred prechodom na curr na ďalší uzol vždy nastavte prev = curr.
  • Ak sa uzol nájde, skontrolujte, či je to jediný uzol v zozname. Ak áno, nastavte head = NULL a free(curr).
  • Ak má zoznam viac ako jeden uzol, skontrolujte, či ide o prvý uzol v zozname. Podmienka na overenie (curr == hlava). Ak áno, presuňte sa na predchádzajúci, kým nedosiahne posledný uzol. Keď prev dosiahne posledný uzol, nastavte head = head -> next a prev -> next = head. Odstrániť kurz.
  • Ak curr nie je prvý uzol, skontrolujeme, či je posledným uzlom v zozname. Podmienkou na overenie je (curr -> next == head).
  • Ak je curr posledným uzlom. Nastavíme prev -> next = head a vymažeme uzol curr pomocou free(curr).
  • Ak uzol, ktorý sa má vymazať, nie je ani prvým, ani posledným uzlom, potom nastavte prev -> next = curr -> next a vymažte curr.
  • Ak sa uzol v zozname nenachádza, vráťte hlavu a nerobte nič.

Nižšie je uvedená implementácia vyššie uvedeného prístupu:

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->dáta = dáta;  ptr1->next = *odkaz_hlavy;  // Ak prepojený zoznam nie je NULL, potom // nastavte ďalší z posledného uzla if (*head_ref != NULL) { // Nájdite uzol pred hlavičkou a // aktualizujte nasledujúci uzol.  Node* temp = *head_ref;  while (temp->next != *head_ref) temp = temp->next;  temp->dalsi = ptr1;  } else // Pre prvý uzol ptr1->next = ptr1;  *odkaz hlavy = ptr1; } // Funkcia na tlač uzlov v danom // kruhovom prepojenom zozname void printList(Node* head) { Node* temp = head;  if (head != NULL) { do { cout<< temp->údajov<< ' ';  temp = temp->Ďalšie;  } while (temp != hlava);  } 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 == kluc && (*hlava)->dalsi == *hlava) { volna(*hlava);  *hlava = NULL;  návrat;  } Uzol *posledny = *hlava, *d;  // Ak má byť hlavička vymazaná if ((*head)->data == key) { // Nájdenie posledného uzla zoznamu while (last->next != *head) last = last->next;  // Ukážte posledný uzol na nasledujúci z // head t.j. druhý uzol // zoznamu last->next = (*head)->next;  zadarmo(*hlava);  *hlava = posledný->ďalší;  návrat;  } // Buď uzol, ktorý sa má vymazať, // nenájdený, alebo sa nedosiahne koniec zoznamu // kým (posledný->ďalší != *hlavička && posledný->ďalší->údaje != kľúč) { posledný = posledný ->ďalší;  } // Ak bol nájdený uzol na vymazanie if (posledný->ďalší->údaje == kľúč) { d = posledný->ďalší;  posledný->ďalší = d->ďalší;  zadarmo(d);  } inak 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->dáta = dáta;  ptr1->next = *odkaz_hlavy;  // Ak prepojený zoznam nie je NULL, potom // nastavte ďalší z posledného uzla if (*head_ref != NULL) { // Nájdite uzol pred hlavičkou a // aktualizujte nasledujúci uzol.  struct Node* temp = *head_ref;  while (temp->next != *head_ref) temp = temp->next;  temp->dalsi = ptr1;  } else // Pre prvý uzol ptr1->next = ptr1;  *odkaz hlavy = ptr1; } // Funkcia na tlač uzlov v danom // kruhovom prepojenom zozname void printList(struct Node* head) { struct Node* temp = head;  if (head != NULL) { do { printf('%d ', temp->data);  temp = temp->ďalší;  } while (temp != hlava);  } printf('
'); } // Funkcia na odstránenie daného uzla // zo zoznamu void deleteNode(struct Node** hlavička, kľúč int) { // Ak je prepojený zoznam prázdny if (*head == NULL) return;  // Ak zoznam obsahuje iba // jeden uzol if ((*head)->data == key && (*head)->next == *head) { free(*head);  *hlava = NULL;  návrat;  } struct Uzol *posledny = *hlava, *d;  // Ak má byť hlavička vymazaná if ((*head)->data == key) { // Nájdenie posledného uzla zoznamu while (last->next != *head) last = last->next;  // Ukážte posledný uzol na nasledujúci z // head t.j. druhý uzol // zoznamu last->next = (*head)->next;  zadarmo(*hlava);  *hlava = posledný->ďalší;  návrat;  } // Buď uzol, ktorý sa má vymazať, // nenájdený, alebo sa nedosiahne koniec zoznamu // kým (posledný->ďalší != *hlavička && posledný->ďalší->údaje != kľúč) { posledný = posledný ->ďalší;  } // Ak bol nájdený uzol na vymazanie if (posledný->ďalší->údaje == kľúč) { d = posledný->ďalší;  posledný->ďalší = d->ďalší;  zadarmo(d);  } else printf('Zadaný uzol sa nenašiel v zozname!!!
'); } // Kód ovládača int main() { // Inicializácia zoznamov ako prázdna štruktúra Node* head = NULL;  // Vytvorený prepojený zoznam bude // 2->5->7->8->10 push(&head, 2);  push(&head, 5);  push(&head, 7);  push(&head, 8);  push(&head, 10);  printf('Zoznam pred odstránením: ');  printList(head);  deleteNode(&head, 7);  printf('Zoznam po vymazani: ');  printList(head);  návrat 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 Push(ref head, 2);  Push(ref head, 5);  Push(ref head, 7);  Push(ref head, 8);  Push(ref head, 10);  Console.Write('Zoznam pred odstránením: ');  PrintList(head);  DeleteNode(ref head, 7);  Console.Write('Zoznam po odstránení: ');  PrintList(head);  } }>
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 hlava = push(head, 2);  hlava = tlačiť(hlava, 5);  hlava = tlačiť(hlava, 7);  hlava = tlačiť(hlava, 8);  hlava = tlačiť(hlava, 10);  console.log('Zoznam pred odstránením: ');  printList(head);  deleteNode(head, 7);  console.log('Zoznam po odstránení: ');  printList(head);>
Python3 
# Python program to delete a given key from linked list class Node: def __init__(self, data): self.data = data self.next = None # Function to insert a node at the # beginning of a Circular linked list def push(head, data): # Create a new node and make head as next of it. newP = Node(data) newP.next = head # If linked list is not NULL then # set the next of last node if head != None: # Find the node before head and # update next of it. temp = head while (temp.next != head): temp = temp.next temp.next = newP else: newP.next = newP head = newP return head # Function to print nodes in a given circular linked list def printList(head): if head == None: print('List is Empty') return temp = head.next print(head.data, end=' ') if (head != None): while (temp != head): print(temp.data, end=' ') temp = temp.next print() # Function to delete a given node # from the list def deleteNode(head, key): # If linked list is empty if (head == None): return # If the list contains only a # single node if (head.data == key and head.next == head): head = None return 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 and 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 = None else: print('Given node is not found in the list!!!') # Driver code # Initialize lists as empty head = None # Created linked list will be # 2->5->7->8->10 hlava = tlačiť (hlava, 2) hlava = tlačiť (hlava, 5) hlava = tlačiť (hlava, 7) hlava = tlačiť (hlava, 8) hlava = tlačiť (hlava, 10) print('Zoznam pred vymazaním: ') printList(head) deleteNode(head, 7) print('Zoznam po vymazaní: ') printList(head)>
Výkon 
List Before Deletion: 10 8 7 5 2 List After Deletion: 10 8 5 2>

Časová zložitosť: O(N), Najhorší prípad nastane, keď prvok, ktorý sa má vymazať, je posledným prvkom a musíme prejsť celým zoznamom.
Pomocný priestor: O(1), ako konštantný priestor navyše sa používa.

uzamknutie aplikácie pre Android

Výhody kruhových prepojených zoznamov:

  • Začiatočným bodom môže byť akýkoľvek uzol. Celý zoznam môžeme prechádzať tak, že začneme z akéhokoľvek bodu. Musíme sa len zastaviť, keď sa znova navštívi prvý navštívený uzol.
  • Užitočné pre implementáciu frontu. Na rozdiel od toto implementácii, nemusíme udržiavať dva ukazovatele pre prednú a zadnú stranu, ak používame kruhový prepojený zoznam. Môžeme udržiavať ukazovateľ na posledný vložený uzol a predný uzol možno vždy získať ako ďalší pred posledným.
  • Kruhové zoznamy sú užitočné v aplikáciách na opakované prechádzanie zoznamu. Napríklad, keď je na počítači spustených viacero aplikácií, je bežné, že operačný systém zaradí spustené aplikácie do zoznamu a potom ich cyklicky prejde, pričom každej z nich poskytne určitý čas na spustenie a potom ich nechá chvíľu čakať. CPU je odovzdaný inej aplikácii. Pre operačný systém je vhodné použiť kruhový zoznam, takže keď sa dostane na koniec zoznamu, môže sa pohybovať na začiatku zoznamu.
  • Kruhové dvojito prepojené zoznamy sa používajú na implementáciu pokročilých dátových štruktúr, ako je napr Fibonacciho halda .
  • Implementácia kruhového prepojeného zoznamu môže byť relatívne jednoduchá v porovnaní s inými zložitejšími dátovými štruktúrami, ako sú stromy alebo grafy.

Nevýhody kruhového prepojeného zoznamu:

  • V porovnaní s jednotlivo prepojenými zoznamami sú kruhové zoznamy zložitejšie.
  • Obrátenie kruhového zoznamu je komplikovanejšie ako jednoduché alebo dvojité obrátenie kruhového zoznamu.
  • Je možné, že sa kód dostane do nekonečnej slučky, ak sa s ním nezaobchádza opatrne.
  • Je ťažšie nájsť koniec zoznamu a ovládať slučku.
  • Hoci kruhové prepojené zoznamy môžu byť v určitých aplikáciách efektívne, ich výkon môže byť v určitých prípadoch pomalší ako iné dátové štruktúry, napríklad keď je potrebné zoznam triediť alebo prehľadávať.
  • Kruhové prepojené zoznamy neposkytujú priamy prístup k jednotlivým uzlom

Aplikácie kruhových prepojených zoznamov:

  • Hry pre viacerých hráčov to využívajú na to, aby každý hráč dostal šancu hrať.
  • Kruhový prepojený zoznam možno použiť na usporiadanie viacerých spustených aplikácií v operačnom systéme. Tieto aplikácie sú iterované operačným systémom.
  • Pri problémoch s alokáciou zdrojov možno použiť kruhové prepojené zoznamy.
  • Kruhové prepojené zoznamy sa bežne používajú na implementáciu kruhových vyrovnávacích pamätí,
  • Kruhové prepojené zoznamy možno použiť pri simulácii a hraní hier.

Prečo kruhový prepojený zoznam?

  • Uzol vždy ukazuje na iný uzol, takže priradenie NULL nie je potrebné.
  • Ako počiatočný bod možno nastaviť ľubovoľný uzol.
  • Uzly sa prechádzajú rýchlo od prvého po posledný.

Ďalšie príspevky: Circular Linked List | Sada 2 (prechádzanie) Kruhový zoznam s jedným odkazom | Vkladanie Ak nájdete nejakú chybu vo vyššie uvedenom kóde/algoritme, napíšte komentáre alebo nájdite iné spôsoby riešenia rovnakého problému