logo

TechCodeview

Ievads sarkanmelnajā kokā

Binārie meklēšanas koki ir fundamentāls datu struktūra, bet to veiktspēja var ciest, ja koks kļūst nelīdzsvarots. Sarkani melni koki ir veids līdzsvarota binārā meklēšanas koks kas izmanto noteikumu kopumu, lai uzturētu līdzsvaru, nodrošinot logaritmisko laika sarežģītību tādām darbībām kā ievietošana, dzēšana un meklēšana , neatkarīgi no koka sākotnējās formas. Sarkani melni koki ir pašbalansējoši, izmantojot vienkāršu krāsu kodēšanas shēmu, lai pielāgotu koku pēc katras modifikācijas.

Sarkanmelns koks



Satura rādītājs

Kas ir sarkanmelns koks?

A Sarkanmelns koks ir pašlīdzsvarotājs binārā meklēšanas koks kur katram mezglam ir papildu atribūts: krāsa, kas var būt vai nu sarkans vai melns . Šo koku galvenais mērķis ir saglabāt līdzsvaru ievietošanas un dzēšanas laikā, nodrošinot efektīvu datu izguvi un manipulācijas.

Sarkanmelno koku īpašības

A Sarkanmelns koks ir šādas īpašības:



  1. Mezgla krāsa : katrs mezgls ir vai nu sarkans, vai melns .
  2. Saknes īpašums : Koka sakne vienmēr ir melns .
  3. Sarkanais īpašums : sarkanajiem mezgliem nevar būt sarkani bērni (nevienā ceļā nav divu secīgu sarkanu mezglu).
  4. Melnais īpašums : katram ceļam no mezgla uz tā pēcnācējiem nulles mezgliem (lapām) ir vienāds skaits melns mezgli.
  5. Lapu īpašums : Visas lapas (NIL mezgli) ir melns .

Šīs īpašības nodrošina, ka garākais ceļš no saknes līdz jebkurai lapai ir ne vairāk kā divas reizes garāks par īsāko ceļu, saglabājot koka līdzsvaru un efektīvu darbību.

Sarkanmelnā koka piemērs

The Pareizs sarkanmelns koks augšējā attēlā nodrošina, ka katram ceļam no saknes līdz lapas mezglam ir vienāds melno mezglu skaits. Šajā gadījumā ir viens (izņemot saknes mezglu).



nbsp

The Nepareizs sarkans melns koks neievēro sarkanmelnās īpašības kā divi sarkani mezgli atrodas blakus viens otram. Vēl viena problēma ir tā, ka vienā no ceļiem uz lapas mezglu nav melnu mezglu, bet pārējie divi satur melnu mezglu.

Kāpēc sarkanmelni koki?

Lielākā daļa BST darbību (piemēram, meklēšana, maks., min., ievietošana, dzēšana utt.) tiek veiktas O(h) laiks, kur h ir augstums BST . Šo operāciju izmaksas var kļūt O(n) par šķību Binārais koks. Ja pārliecināsimies, ka kokam saglabājas augstums O(log n) pēc katras ievietošanas un dzēšanas mēs varam garantēt augšējo robežu O(log n) visām šīm operācijām. Sarkanmelnā koka augstums vienmēr ir O(log n) kur n ir mezglu skaits kokā.

kungs Nr.AlgoritmsLaika sarežģītība
1.MeklētO(log n)
2.IevietotO(log n)
3.DzēstO(log n)

Salīdzinājums ar AVL koks :

AVL koki ir līdzsvarotāki salīdzinājumā ar sarkanmelnajiem kokiem, taču tie var izraisīt lielāku rotāciju ievietošanas un dzēšanas laikā. Tātad, ja jūsu lietojumprogramma ir saistīta ar biežu ievietošanu un dzēšanu, priekšroka jādod sarkanmelnajiem kokiem. Un, ja ievietošana un dzēšana notiek retāk un meklēšana ir biežāka darbība, tad AVL koks priekšroka jādod nevis sarkanmelnajam kokam.

Kā sarkanmelns koks nodrošina līdzsvaru?

Vienkāršs piemērs, lai saprastu balansēšanu, ir tāds, ka sarkanmelnajā kokā nav iespējama 3 mezglu ķēde. Mēs varam izmēģināt jebkuru krāsu kombināciju un pārbaudīt, vai tās visas pārkāpj sarkanā-melnā koka īpašību.

Pareiza trīs mezglu sarkanmelna koka struktūra

stīgu sadalīšana c++

Interesanti punkti par sarkanmelno koku:

  • The melns sarkanmelnā koka augstums ir melno mezglu skaits ceļā no saknes mezgla līdz lapas mezglam. Lapu mezgli arī tiek skaitīti kā melns mezgli. Tātad sarkanmelns auguma koks h ir melns augstums>= h/2 .
  • Sarkanmelna koka augstums ar n mezgli ir h<= 2 log 2 (n + 1) .
  • Visas lapas (NIL) ir melns .
  • The melns mezgla dziļums ir definēts kā melno mezglu skaits no saknes līdz šim mezglam, t.i., melno priekšteču skaits.

Pamatdarbības ar sarkanmelnu koku:

Galvenās darbības ar sarkanmelnu koku ietver:

  1. Ievietošana
  2. Meklēt
  3. Dzēšana
  4. Rotācija

1. Ievietošana

Jauna mezgla ievietošana sarkanmelnajā kokā ietver divpakāpju procesu: standarta izpildi binārā meklēšanas koka (BST) ievietošana , kam seko jebkādu Red-Black īpašību pārkāpumu novēršana.

Ievietošanas soļi

  1. BST ieliktnis : ievietojiet jauno mezglu tāpat kā standarta BST.
  2. Novērsiet pārkāpumus :
    • Ja jaunā mezgla vecāks ir melns , neviens īpašums netiek pārkāpts.
    • Ja vecāks ir sarkans , koks var pārkāpt sarkano īpašumu, kas prasa labojumus.

Pārkāpumu novēršana ievietošanas laikā

Pēc jaunā mezgla ievietošanas kā a sarkans mezglā, mēs varam saskarties ar vairākiem gadījumiem atkarībā no mezgla vecāka un tēvoča (vecāka brāļa un māsas) krāsām:

  • 1. gadījums: onkulis ir sarkans : pārkrāsojiet vecāku un tēvoci uz melns , un vecvecāks uz sarkans . Pēc tam virzieties uz augšu kokā, lai pārbaudītu turpmākos pārkāpumus.
  • 2. gadījums: onkulis ir melns :
    • 2.1. apakšgadījums: mezgls ir pareizais bērns : veiciet vecāku pagriešanu pa kreisi.
    • 2.2. apakšgadījums: mezgls ir kreisais bērns : pagrieziet vecvecāku pa labi un atbilstoši pārkrāsojiet.

2. Meklēšana

Mezgla meklēšana sarkanmelnajā kokā ir līdzīga meklēšanai standartā Binārais meklēšanas koks (BST) . Meklēšanas darbība tiek veikta pa tiešo ceļu no sakne uz a lapu , salīdzinot mērķa vērtību ar pašreizējā mezgla vērtību un attiecīgi pārvietojot pa kreisi vai pa labi.

Meklēšanas soļi

  1. Sāciet no saknes : sāciet meklēšanu saknes mezglā.
  2. Šķērsojiet koku :
    • Ja mērķa vērtība ir vienāda ar pašreizējā mezgla vērtību, mezgls tiek atrasts.
    • Ja mērķa vērtība ir mazāka par pašreizējā mezgla vērtību, pārejiet uz kreiso bērnu.
    • Ja mērķa vērtība ir lielāka par pašreizējā mezgla vērtību, pārejiet uz pareizo pakārtoto vērtību.
  3. Atkārtojiet : turpiniet šo procesu, līdz tiek atrasta mērķa vērtība vai tiek sasniegts NIL mezgls (norāda, ka vērtības kokā nav).

3. Dzēšana

Mezgla dzēšana no sarkanmelnā koka ietver arī divpakāpju procesu: tiek veikta BST dzēšana, kam seko visu radušos pārkāpumu novēršana.

Dzēšanas soļi

  1. BST dzēšana : noņemiet mezglu, izmantojot standarta BST noteikumus.
  2. Labojiet Double Black :
    • Ja melnais mezgls tiek dzēsts, var rasties dubults melns stāvoklis, kas prasa īpašus labojumus.

Pārkāpumu novēršana dzēšanas laikā

Kad melnais mezgls tiek dzēsts, dubultā melnā problēma tiek risināta, pamatojoties uz brāļa un māsas un tā bērnu krāsām:

  • 1. gadījums: brālis ir sarkans : pagrieziet vecāku un pārkrāsojiet brāli un māsu.
  • 2. gadījums: brālis ir melnādains :
    • 2.1. apakšlieta: brāļu un māsu bērni ir melnādainie : pārkrāsojiet brāli un pavairojiet dubulto melno uz augšu.
    • 2.2. apakšgadījums: vismaz viens no brāļa un māsas bērniem ir sarkans :
      • Ja brāļa un māsas tālākais bērns ir sarkans : veiciet vecāku un brāļa un māsas rotāciju un atbilstoši pārkrāsojiet.
      • Ja brāļa un māsas tuvākais bērns ir sarkans : pagrieziet brāli un māsu un tā bērnu, pēc tam rīkojieties, kā norādīts iepriekš.

4. Rotācija

Rotācijas ir būtiskas darbības, lai uzturētu līdzsvarotu sarkanmelnā koka (RBT) struktūru. Tie palīdz saglabāt koka īpašības, nodrošinot, ka garākais ceļš no saknes līdz jebkurai lapai ir ne vairāk kā divas reizes garāks par īsāko ceļu. Rotācijas ir divu veidu: pagriezieni pa kreisi un pareizas rotācijas.

1. Rotācija pa kreisi

Rotācija pa kreisi mezglā 𝑥 x kustas 𝑥 x uz leju pa kreisi un tā labais bērns 𝑦 un līdz jāņem 𝑥 x vieta.

Kreisās rotācijas vizualizācija 
Before Rotation:  x      y   /    a b  After Left Rotation:  y  /   x b  /  a>

Rotācijas pa kreisi soļi:

  1. Iestatīt un būt īstajam bērnam x .
  2. Kustēties un ’s atstāj apakškoku uz x labais apakškoks.
  3. Atjauniniet vecāku x un un .
  4. Atjaunināt x 's vecāks, uz kuru norādīt un tā vietā x .
  5. Iestatīt un ’s atstājis bērnu x .
  6. Atjaunināt x ’s vecāks uz un .

Kreisās rotācijas pseidokods:

Rotācija pa kreisi 
// Utility function to perform left rotation void leftRotate(Node* x) {  Node* y = x->pa labi;  x->pa labi = y->pa kreisi;  if (y->left != NIL) { y->left->parent = x;  } y->vecāks = x->vecāks;  if (x->parent == nullptr) { sakne = y;  } else if (x == x->parent->left) { x->parent->left = y;  } else { x->parent->right = y;  } y->pa kreisi = x;  x->vecāks = y; }>

2. Rotācija pa labi

Pareiza rotācija mezglā 𝑥 x kustas 𝑥 x uz leju pa labi un tās kreisais bērns 𝑦 un līdz jāņem 𝑥 x vieta.

Labās rotācijas vizualizācija: 
Befor Right Rotation:   x  /  y  /   a b After Right Rotation:  y  /   a x  /  b>

Labās rotācijas soļi:

  1. Iestatīt un būt kreisajam bērnam x .
  2. Kustēties un ’s tiesības apakškoks uz x pa kreisi apakškoks.
  3. Atjauniniet vecāku x un un .
  4. Atjaunināt x 's vecāks, uz kuru norādīt un tā vietā x .
  5. Iestatīt un pareizais bērns x .
  6. Atjaunināt x ’s vecāks uz un .

Labās rotācijas pseidokods:

C++ 
// Utility function to perform right rotation void rightRotate(Node* x) {  Node* y = x->pa kreisi;  x->pa kreisi = y->pa labi;  if (y->right != NIL) { y->right->parent = x;  } y->vecāks = x->vecāks;  if (x->parent == nullptr) { sakne = y;  } else if (x == x->parent->right) { x->parent->right = y;  } else { x->parent->left = y;  } y->pa labi = x;  x->vecāks = y; }>

Kad veikt rotācijas?

Rotācijas sarkanmelnajos kokos parasti tiek veiktas ievietošanas un dzēšanas laikā, lai saglabātu koka īpašības. Tālāk ir norādīti rotācijas scenāriji.

1. Pārkāpumu novēršana pēc ievietošanas

Kad tiek ievietots jauns mezgls, tas vienmēr ir sarkanā krāsā. Tas var radīt sarkanmelnā koka īpašību pārkāpumus, jo īpaši:

  • Saknei jābūt melns .
  • sarkans mezgliem nevar būt sarkans bērniem.

Gadījuma analīze ievietojumu fiksēšanai:

  • 1. gadījums: pārkrāsošana un pavairošana uz augšu
    • Ja jaunā mezgla vecāks un tēvocis ir abi sarkans , pārkrāsojiet vecāku un tēvoci uz melns , un vecvecāks uz sarkans . Pēc tam rekursīvi piemērojiet labojumu vecvecākam.
  • 2. gadījums: pagriešana un pārkrāsošana
    • Ja jaunā mezgla tēvocis ir melns un jaunais mezgls ir kreisā bērna labais bērns (vai otrādi), veiciet pagriešanu, lai pārvietotu jauno mezglu uz augšu un izlīdzinātu to.
    • Ja jaunā mezgla tēvocis ir melns un jaunais mezgls ir kreisā bērna kreisais bērns (vai labais no labās puses), veiciet rotāciju un pārkrāsojiet vecāku un vecvecāku, lai novērstu pārkāpumu.

2. Pārkāpumu novēršana pēc dzēšanas

Pēc dzēšanas, iespējams, koks būs jālabo, lai atjaunotu rekvizītus:

  • Kad melnais mezgls tiek noņemts vai sarkanais mezgls tiek aizstāts ar melnu, var rasties dubultmelna situācija.

Gadījuma analīze dzēšanas labošanai:

  • 1. gadījums: brālis ir sarkans
    • Pārkrāsojiet brāli un māsu un vecākus un veiciet rotāciju.
  • 2. gadījums: brālis un māsa ir melnādains ar melniem bērniem
    • Pārkrāsojiet brāli un māsu uz sarkanu un pārceliet problēmu uz vecāku.
  • 3. gadījums: brālis un māsa ir melnādains ar vismaz vienu sarkanu bērnu
    • Pagrieziet un pārkrāsojiet, lai novērstu dubultmelnās krāsas problēmu.

Red-Black Tree ieviešana:

Šeit ir detalizēta sarkanmelnā koka ieviešana, tostarp ievietošanas, meklēšanas un pagriešanas funkcijas:

C++ 
#include  using namespace std; // Node structure for the Red-Black Tree struct Node {  int data;  string color;  Node *left, *right, *parent;  Node(int data)  : data(data)  , color('RED')  , left(nullptr)  , right(nullptr)  , parent(nullptr)  {  } }; // Red-Black Tree class class RedBlackTree { private:  Node* root;  Node* NIL;  // Utility function to perform left rotation  void leftRotate(Node* x)  {  Node* y = x->pa labi;  x->pa labi = y->pa kreisi;  if (y->left != NIL) { y->left->parent = x;  } y->vecāks = x->vecāks;  if (x->parent == nullptr) { sakne = y;  } else if (x == x->parent->left) { x->parent->left = y;  } else { x->parent->right = y;  } y->pa kreisi = x;  x->vecāks = y;  } // Lietderības funkcija, lai veiktu rotāciju pa labi void rightRotate(Node* x) { Node* y = x->left;  x->pa kreisi = y->pa labi;  if (y->right != NIL) { y->right->parent = x;  } y->vecāks = x->vecāks;  if (x->parent == nullptr) { sakne = y;  } else if (x == x->parent->right) { x->parent->right = y;  } else { x->parent->left = y;  } y->pa labi = x;  x->vecāks = y;  } // Funkcija sarkanmelnā koka rekvizītu labošanai pēc // ievietošanas void fixInsert(Node* k) { while (k != root && k->parent->color == 'RED') { if (k->vecāks == k->vecāks->vecāks->pa kreisi) { Mezgls* u = k->vecāks->vecāks->pa labi; // tēvocis if (u->krāsa == 'SARKANA') { k->vecāks->krāsa = 'MELNA';  u->krāsa = 'MELNA';  k->vecāks->vecāks->krāsa = 'SARKANA';  k = k->vecāks->vecāks;  } else { if (k == k->parent->right) { k = k->parent;  pa kreisiPagriezt(k);  } k->parent->color = 'MELNS';  k->vecāks->vecāks->krāsa = 'SARKANS';  rightRotate(k->parent->parent);  } } else { Mezgls* u = k->vecāks->vecāks->pa kreisi; // tēvocis if (u->krāsa == 'SARKANA') { k->vecāks->krāsa = 'MELNA';  u->krāsa = 'MELNA';  k->parent->parent->color = 'SARKANS';  k = k->vecāks->vecāks;  } else { if (k == k->vecāks->pa kreisi) { k = k->vecāks;  pa labiPagriezt(k);  } k->parent->color = 'MELNS';  k->vecāks->vecāks->krāsa = 'SARKANS';  leftRotate(k->parent->parent);  } } } sakne->krāsa = 'MELNA';  } // Inorder traversal helper function void inorderHelper(Node* node) { if (node ​​!= NIL) { inorderHelper(node->left);  cout<< node->datus<< ' ';  inorderHelper(node->pa labi);  } } // Meklēšanas palīga funkcija Node* searchHelper(Node* node, int data) { if (node ​​== NIL || data == node->data) { return node;  } ja (dati< node->dati) { return searchHelper(mezgls->pa kreisi, dati);  } return searchHelper(mezgls->pa labi, dati);  } public: // Konstruktors RedBlackTree() { NIL = new Node(0);  NIL->krāsa = 'MELNA';  NIL->pa kreisi = NIL->pa labi = NIL;  sakne = NIL;  } // Ievietošanas funkcija void insert(int data) { Node* new_node = new Node(data);  jauns_mezgls->pa kreisi = NIL;  new_node->right = NIL;  Mezgls* vecāks = nullptr;  Mezgls* strāva = sakne;  // BST ievietot while (current != NIL) { vecāks = pašreizējais;  if (jauns_mezgls->dati< current->dati) { strāva = strāva->pa kreisi;  } else { pašreizējais = pašreizējais->pa labi;  } } new_node->parent = vecāks;  if (vecāks == nullptr) { root = new_node;  } else if (new_node->data< parent->dati) { vecāks->pa kreisi = new_node;  } else { vecāks->pa labi = new_node;  } if (jauns_mezgls->parent == nullptr) { new_node->color = 'BLACK';  atgriešanās;  } if (jauns_mezgls->vecāks->vecāks == nullptr) { return;  } fixInsert(jauns_mezgls);  } // Inorder traversal void inorder() { inorderHelper(root); } // Meklēšanas funkcija Node* search(int data) { return searchHelper(root, data);  } }; int main() { RedBlackTree rbt;  // Elementu ievietošana rbt.insert(10);  rbt.insert(20);  rbt.insert(30);  rbt.insert(15);  // Inorder traversal cout<< 'Inorder traversal:' << endl;  rbt.inorder(); // Output: 10 15 20 30  // Search for a node  cout << '
Search for 15: '  << (rbt.search(15) != rbt.search(0))  << endl; // Output: 1 (true)  cout << 'Search for 25: '  << (rbt.search(25) != rbt.search(0))  << endl; // Output: 0 (false)  return 0; }>

Sarkanmelno koku priekšrocības:

  • Līdzsvarots: Red-Black Trees ir pašbalansējoši, kas nozīmē, ka tie automātiski uztur līdzsvaru starp kreisā un labā apakškoku augstumu. Tas nodrošina, ka meklēšanas, ievietošanas un dzēšanas darbības sliktākajā gadījumā aizņem O(log n) laiku.
  • Efektīva meklēšana, ievietošana un dzēšana: Pateicoties sabalansētajai struktūrai, Red-Black Trees piedāvā efektīvas darbības. Sliktākajā gadījumā meklēšana, ievietošana un dzēšana prasa O(log n) laiku.
  • Vienkārši īstenojams: Red-Black Tree īpašumu uzturēšanas noteikumi ir salīdzinoši vienkārši un vienkārši īstenojami.
  • Plaši lietots: Red-Black Trees ir populāra izvēle dažādu datu struktūru, piemēram, karšu, kopu un prioritāro rindu, ieviešanai.

Sarkanmelno koku trūkumi:

  • Sarežģītāki nekā citi līdzsvaroti koki: Salīdzinot ar vienkāršākiem līdzsvarotiem kokiem, piemēram, AVL kokiem, sarkanmelnajiem kokiem ir sarežģītāki ievietošanas un dzēšanas noteikumi.
  • Pastāvīgās pieskaitāmās izmaksas: Red-Black Tree īpašību saglabāšana rada nelielu papildu izdevumu katrai ievietošanas un dzēšanas darbībai.
  • Nav optimāls visiem lietošanas gadījumiem: Lai gan sarkanmelnie koki ir efektīvi lielākajai daļai darbību, tie var nebūt labākā izvēle lietojumprogrammām, kurās ir nepieciešama bieža ievietošana un dzēšana, jo pastāvīgās pieskaitāmās izmaksas var kļūt ievērojamas.

Sarkanmelno koku pielietojumi:

  • Karšu un komplektu ieviešana: Red-Black Trees bieži izmanto, lai ieviestu kartes un kopas, kur efektīvai meklēšanai, ievietošanai un dzēšanai ir izšķiroša nozīme.
  • Prioritārās rindas: Red-Black Trees var izmantot prioritāro rindu ieviešanai, kur elementi tiek sakārtoti, pamatojoties uz to prioritāti.
  • Failu sistēmas: Red-Black Trees tiek izmantoti dažās failu sistēmās, lai pārvaldītu failu un direktoriju struktūras.
  • Atmiņā esošās datu bāzes: Red-Black Trees dažreiz tiek izmantotas atmiņas datu bāzēs, lai efektīvi uzglabātu un izgūtu datus.
  • Grafika un spēļu izstrāde: Red-Black Trees var izmantot grafikā un spēlē attīstību tādiem uzdevumiem kā sadursmes noteikšana un ceļa noteikšana.

Bieži uzdotie jautājumi (BUJ) par sarkanmelno koku:

1. Kas ir sarkanmelns koks?

Red-Black Tree ir pašbalansējošs binārs meklēšanas koks, kas saglabā līdzsvaru starp tā kreisā un labā apakškoku augstumiem. Tas nodrošina, ka meklēšanas, ievietošanas un dzēšanas darbības sliktākajā gadījumā aizņem O(log n) laiku. Red-Black Trees tiek plaši izmantoti dažādās lietojumprogrammās, kur nepieciešamas efektīvas datu struktūras.

2. Kā sarkanmelns koks saglabā līdzsvaru?

Sarkanmelnie koki saglabā līdzsvaru, ieviešot īpašus noteikumus par mezglu krāsām (SARKANĀ vai MELNO) un attiecībām starp tiem. Šie noteikumi nodrošina, ka koks paliek līdzsvarots un ka augstuma starpība starp kreiso un labo apakškoku ir ne vairāk kā 1.

sniegs vs ledus

3. Kādas ir sarkanmelnā koka izmantošanas priekšrocības?

  • Līdzsvarots: Red-Black Trees ir pašbalansējoši, nodrošinot efektīvas meklēšanas, ievietošanas un dzēšanas darbības.
  • Efektīvs: Tie piedāvā O(log n) laika sarežģītību lielākajai daļai darbību.
  • Vienkārši īstenojams: Red-Black Tree īpašumu uzturēšanas noteikumi ir samērā vienkārši.
  • Plaši lietots: Tie ir populāra izvēle dažādu datu struktūru un algoritmu ieviešanai.

4. Kādi ir sarkanmelnā koka izmantošanas trūkumi?

  • Salīdzinot ar vienkāršākiem līdzsvarotiem kokiem, piemēram, AVL kokiem, sarkanmelnajiem kokiem ir sarežģītāki ievietošanas un dzēšanas noteikumi.
  • Red-Black Tree īpašību saglabāšana rada nelielu papildu izdevumu katrai ievietošanas un dzēšanas darbībai.
  • Lietojumprogrammām ar biežu ievietošanu un dzēšanu citas līdzsvarotas koku struktūras varētu būt piemērotākas.

5. Kādi ir daži izplatīti sarkanmelno koku pielietojumi?

  • Karšu un komplektu ieviešana
  • Prioritārās rindas
  • Failu sistēmas
  • Atmiņas datu bāzes
  • Grafika un spēļu izstrāde (sadursmju noteikšana, ceļa noteikšana)
  • Red-Black Tree definīcija un nozīme DSA
  • Pašbalansējošie binārie meklēšanas koki
  • Red Black Tree vs AVL Tree
  • Kāda ir atšķirība starp kaudzi un sarkanmelno koku?
  • Ievietošana sarkanmelnajā kokā
  • Dzēšana sarkanmelnajā kokā
  • Sarkanmelnie koki | Ievietošana no augšas uz leju