Before Rotation:  x      y   /    a b  After Left Rotation:  y  /   x b  /  a>

// Utility function to perform left rotation void leftRotate(Node* x) {  Node* y = x->dreapta;  x->dreapta = y->stânga;  if (y->left != NIL) { y->left->parent = x;  } y->parent = x->parent;  if (x->parent == nullptr) { root = y;  } else if (x == x->parent->left) { x->parent->left = y;  } else { x->părinte->dreapta = y;  } y->stânga = x;  x->părinte = y; }>>> 
2. Rotire dreapta
O rotație la dreapta la nodul 𝑥    X    se mișcă 𝑥    X    jos în dreapta și copilul său stâng 𝑦    și    până să ia 𝑥    X    locul lui.
Vizualizarea rotației la dreapta:    Pașii de rotație la dreapta:    
A stabilit      și      a fi copilul stâng al      X      .
Mișcare    și    subarborele potrivit pentru    X    subarborele din stânga lui.
Actualizați părintele lui      X      și      și      .
Actualizați    X    părintele lui să arate      și      în loc de      X      .
A stabilit    și    copilul potrivit    X    .
Actualizați    X    părintele lui    și    .
    Pseudocod de rotație la dreapta:    
C++ 
// Utility function to perform right rotation void rightRotate(Node* x) {  Node* y = x->stânga;  x->stânga = y->dreapta;  dacă (y->dreapta != NIL) { y->dreapta->părinte = x;  } y->parent = x->parent;  if (x->parent == nullptr) { root = y;  } else if (x == x->părinte->dreapta) { x->părinte->dreapta = y;  } else { x->parent->left = y;  } y->dreapta = x;  x->părinte = y; }>>> 
Când se efectuează rotații?
Rotațiile în arbori roșu-negru sunt de obicei efectuate în timpul inserărilor și ștergerii pentru a menține proprietățile arborelui. Mai jos sunt scenariile pentru rotații:
declarația bash if
 
1. Remedierea încălcărilor după inserare
Când este introdus un nou nod, acesta este întotdeauna colorat în roșu. Acest lucru poate crea încălcări ale proprietăților arborelui roșu-negru, în special:
 
Rădăcina trebuie să fie    negru    .
    roșu    nodurile nu pot avea    roșu    copii.
    Analiza cazului pentru fixarea inserțiilor:    
 
    Cazul 1: Recolorarea și propagarea în sus    
Dacă părintele și unchiul noului nod sunt amândoi    roșu    , recolorează părintele și unchiul la    negru    , iar bunicul să    roșu    . Apoi, aplicați recursiv remedierea bunicului.
    Cazul 2: Rotire și Recolorare    
Dacă unchiul noului nod este    negru    iar noul nod este copilul drept al unui copil stâng (sau invers), efectuați o rotație pentru a muta noul nod în sus și a-l alinia.
Dacă unchiul noului nod este    negru    iar noul nod este copilul stâng al unui copil stâng (sau dreapta unui drept), efectuați o rotație și recolorați părintele și bunicul pentru a remedia încălcarea.
2. Remedierea încălcărilor după ștergere
După ștergere, arborele ar putea avea nevoie de reparații pentru a restabili proprietățile:
 
Când un nod negru este îndepărtat sau un nod roșu este înlocuit cu un nod negru, poate apărea o situație de dublu negru.
    Analiza cazului pentru remedierea ștergerilor:    
 
    Cazul 1: Fratele este roșu    
Recolorează fratele și părintele și efectuează o rotație.
    Cazul 2: Fratele este negru cu copii negri    
Recolorați fratele în roșu și mutați problema la părinte.
    Cazul 3: Fratele este negru cu cel puțin un copil roșu    
Rotiți și recolorați pentru a remedia problema dublu-negru.
Implementarea arborelui roșu-negru:
Iată o implementare detaliată a unui arbore roșu-negru, inclusiv funcții de inserare, căutare și rotație:
C++dreapta;  x->dreapta = y->stânga;  if (y->left != NIL) { y->left->parent = x;  } y->parent = x->parent;  if (x->parent == nullptr) { root = y;  } else if (x == x->parent->left) { x->parent->left = y;  } else { x->părinte->dreapta = y;  } y->stânga = x;  x->părinte = y;  } // Funcție utilitar pentru a efectua rotația la dreapta void rightRotate(Nod* x) { Nod* y = x->left;  x->stânga = y->dreapta;  dacă (y->dreapta != NIL) { y->dreapta->părinte = x;  } y->parent = x->parent;  if (x->parent == nullptr) { root = y;  } else if (x == x->părinte->dreapta) { x->părinte->dreapta = y;  } else { x->parent->left = y;  } y->dreapta = x;  x->părinte = y;  } // Funcție pentru a remedia proprietățile arborelui roșu-negru după // inserare void fixInsert(Node* k) { while (k != root && k->parent->color == 'RED') { if (k->părinte == k->părinte->părinte->stânga) { Nodul* u = k->părinte->părinte->dreapta; // uncle if (u->color == 'RED') { k->parent->color = 'BLACK';  u->culoare = 'NEGRU';  k->parent->parent->culoare = 'RED';  k = k->părinte->părinte;  } else { if (k == k->părinte->dreapta) { k = k->părinte;  stângaRotire(k);  } k->parent->culoare = 'NEGRU';  k->parent->parent->culoare = 'RED';  dreaptaRotate(k->părinte->părinte);  } } else { Nod* u = k->parent->parent->left; // uncle if (u->color == 'RED') { k->parent->color = 'BLACK';  u->culoare = 'NEGRU';  k->parent->parent->culoare = 'RED';  k = k->părinte->părinte;  } else { if (k == k->părinte->stânga) { k = k->părinte;  dreaptaRotire(k);  } k->parent->culoare = 'NEGRU';  k->parent->parent->culoare = 'RED';  stângaRotire(k->părinte->părinte);  } } } root->color = 'NEGRU';  } // Inorder traversal helper function void inorderHelper(Nod* node) { if (nod != NIL) { inorderHelper(nod->left);  cout<< node->date<< ' ';  inorderHelper(node->dreapta);  } } // Funcția de ajutor de căutare Nod* searchHelper(Nod* nod, int date) { if (nod == NIL || data == node->data) { return node;  } dacă (date< node->date) { return searchHelper(nod->stânga, date);  } return searchHelper(nod->dreapta, date);  } public: // Constructor RedBlackTree() { NIL = new Node(0);  NIL->culoare = 'NEGRU';  NIL->stânga = NIL->dreapta = NIL;  rădăcină = NIL;  } // Funcția de inserare void insert(int data) { Nod* new_node = new Node(data);  nod_nou->stânga = NIL;  nod_nou->dreapta = NIL;  Nod* parent = nullptr;  Nod* curent = rădăcină;  // BST introduce while (current != NIL) { parent = current;  if (nod_nou->date< current->date) { curent = curent->stânga;  } else { curent = curent->dreapta;  } } nod_nou->părinte = părinte;  if (parent == nullptr) { root = new_node;  } else if (nod_nou->date< parent->date) { parent->left = new_node;  } else { parent->right = new_node;  } if (nod_nou->părinte == nullptr) { nod_nou->culoare = 'NEGRU';  întoarcere;  } if (nod_nou->părinte->părinte == nullptr) { return;  } fixInsert(nod_nou);  } // Inorder traversal void inorder() { inorderHelper(root); } // Funcția de căutare Nod* search(int data) { return searchHelper(root, data);  } }; int main() { RedBlackTree rbt;  // Inserarea elementelor rbt.insert(10);  rbt.inserat(20);  rbt.inserat(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; }>
  
Avantajele copacilor roșu-negru:
    Echilibrat:    Copacii roșu-negru se auto-echilibrează, ceea ce înseamnă că mențin automat un echilibru între înălțimile subarborilor din stânga și din dreapta. Acest lucru asigură că operațiunile de căutare, inserare și ștergere necesită timp O(log n) în cel mai rău caz.
    Căutare, inserare și ștergere eficiente:    Datorită structurii lor echilibrate, Copacii Roșu-Negru oferă operațiuni eficiente. Căutarea, inserarea și ștergerea necesită timp O(log n) în cel mai rău caz.
    Simplu de implementat:    Regulile pentru menținerea proprietăților arborelui roșu-negru sunt relativ simple și ușor de implementat.
    Utilizate pe scară largă:    Arborii roșu-negru sunt o alegere populară pentru implementarea diferitelor structuri de date, cum ar fi hărți, seturi și cozi de prioritate.
Dezavantajele copacilor roșu-negru:
    Mai complex decât alți arbori echilibrați:    În comparație cu arborii echilibrați mai simpli precum arborii AVL, arborii roșu-negru au reguli de inserare și ștergere mai complexe.
    Costul general constant:    Menținerea proprietăților arborelui roșu-negru adaugă o mică suprasarcină la fiecare operație de inserare și ștergere.
    Nu este optim pentru toate cazurile de utilizare:    Deși eficient pentru majoritatea operațiunilor, Red-Black Trees ar putea să nu fie cea mai bună alegere pentru aplicațiile în care sunt necesare inserări și ștergeri frecvente, deoarece suprasolicitarea constantă poate deveni semnificativă.
Aplicații ale arborilor roșu-negru:
    Implementarea de hărți și seturi:    Arborele roșu-negru sunt adesea folosiți pentru a implementa hărți și seturi, unde căutarea, inserarea și ștergerea eficiente sunt cruciale.
    Cozile prioritare:    Arborii roșu-negru pot fi utilizați pentru a implementa cozi de prioritate, în care elementele sunt ordonate în funcție de prioritatea lor.
    Sisteme de fișiere:    Arborii roșu-negru sunt utilizați în unele sisteme de fișiere pentru a gestiona structurile de fișiere și directoare.
    Baze de date în memorie:    Arborele roșu-negru sunt uneori folosiți în bazele de date în memorie pentru a stoca și a prelua datele în mod eficient.
    Dezvoltare grafică și joc:    Red-Black Trees poate fi folosit în grafică și joc dezvoltare pentru sarcini precum detectarea coliziunilor și identificarea căii.
Întrebări frecvente (FAQs) despre Red-Black Tree:
1. Ce este un copac roșu-negru?
 
Un arbore roșu-negru este un arbore de căutare binar cu auto-echilibrare care menține un echilibru între înălțimile subarborilor din stânga și din dreapta. Acest lucru asigură că operațiunile de căutare, inserare și ștergere necesită timp O(log n) în cel mai rău caz. Arborele roșu-negru sunt utilizați pe scară largă în diverse aplicații în care sunt necesare structuri eficiente de date.
 
2. Cum își menține echilibrul un copac roșu-negru?
 
Arborele Roșu-Negru își mențin echilibrul prin aplicarea unor reguli specifice privind culorile nodurilor (ROȘU sau NEGRU) și relațiile dintre ele. Aceste reguli asigură că arborele rămâne echilibrat și că diferența de înălțime dintre subarborele din stânga și din dreapta este de cel mult 1.
 
3. Care sunt avantajele folosirii unui arbore roșu-negru?
 
    Echilibrat:    Arborele roșu-negru se auto-echilibrează, asigurând operațiuni eficiente de căutare, inserare și ștergere.
    Eficient:    Ele oferă complexitate de timp O(log n) pentru majoritatea operațiunilor.
    Simplu de implementat:    Regulile pentru menținerea proprietăților arborelui roșu-negru sunt relativ simple.
    Utilizate pe scară largă:    Sunt o alegere populară pentru implementarea diferitelor structuri de date și algoritmi.
4. Care sunt dezavantajele folosirii unui arbore roșu-negru?
 
În comparație cu arborii echilibrați mai simpli precum arborii AVL, arborii roșu-negru au reguli de inserare și ștergere mai complexe.
Menținerea proprietăților arborelui roșu-negru adaugă o mică suprasarcină la fiecare operație de inserare și ștergere.
Pentru aplicațiile cu inserții și ștergeri frecvente, alte structuri de arbore echilibrate ar putea fi mai potrivite.
5. Care sunt câteva aplicații comune ale arborilor roșu-negru?
 
Implementarea de hărți și seturi
Cozile prioritare
Sisteme de fișiere
Baze de date în memorie
Dezvoltare grafică și joc (detecția coliziunilor, identificarea căii)
    Articole similare:    
 Definiția și semnificația arborelui roșu-negru în DSA 
 Arbori de căutare binari cu auto-echilibrare 
 Red Black Tree vs AVL Tree 
 Care este diferența dintre Heap și Red-Black Tree? 
 Inserție în arbore roșu-negru 
 Ștergere în arbore roșu-negru 
 Copaci roșu-negri | Inserție de sus în jos