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->dret;  x->dreta = y->esquerra;  if (y->esquerra != NIL) { y->esquerra->pare = x;  } y->parent = x->parent;  if (x->parent == nullptr) { arrel = y;  } else if (x == x->pare->esquerra) { x->pare->esquerra = y;  } else { x->parent->dret = y;  } y->esquerra = x;  x->parent = y; }>>> 
2. Rotació dreta
Una rotació dreta al node 𝑥    x    es mou 𝑥    x    cap avall a la dreta i el seu fill esquerre 𝑦    i    fins a prendre 𝑥    x    el lloc.
Visualització de la rotació dreta:    Passos de rotació dreta:    
Conjunt      i      ser el fill esquerre de      x      .
Mou-te    i    el subarbre correcte a    x    el subarbre esquerre.
Actualitza el pare de      x      i      i      .
Actualització    x    el pare per assenyalar      i      en lloc de      x      .
Conjunt    i    el nen adequat    x    .
Actualització    x    el pare a    i    .
    Pseudocodi de rotació dreta:    
C++ 
// Utility function to perform right rotation void rightRotate(Node* x) {  Node* y = x->esquerra;  x->esquerra = y->dreta;  if (y->dreta != NIL) { y->dreta->pare = x;  } y->parent = x->parent;  if (x->parent == nullptr) { arrel = y;  } else if (x == x->parent->dret) { x->pare->dret = y;  } else { x->parent->esquerra = y;  } y->dreta = x;  x->parent = y; }>>> 
Quan fer les rotacions?
Les rotacions als arbres vermell-negre es realitzen normalment durant les insercions i les supressions per mantenir les propietats de l'arbre. A continuació es mostren els escenaris per a les rotacions:
 
1. Arreglar les infraccions després de la inserció
Quan s'insereix un nou node, sempre està de color vermell. Això pot crear violacions de les propietats de l'arbre vermell-negre, concretament:
 
L'arrel ha de ser    negre    .
    Vermell    els nodes no poden tenir    vermell    nens.
    Anàlisi de casos per arreglar insercions:    
 
    Cas 1: Recolorir i propagar cap amunt    
Si el pare i l'oncle del nou node són tots dos    vermell    , torna a pintar el pare i l'oncle    negre    , i l'avi a    vermell    . A continuació, apliqueu recursivament la correcció a l'avi.
    Cas 2: Rotació i recolor    
Si l'oncle del nou node és    negre    i el nou node és el fill dret d'un fill esquerre (o viceversa), feu una rotació per moure el nou node cap amunt i alinear-lo.
Si l'oncle del nou node és    negre    i el nou node és el fill esquerre d'un fill esquerre (o dret d'un dret), realitzeu una rotació i torneu a pintar el pare i l'avi per solucionar la violació.
2. Arreglar les infraccions després de la supressió
Després de la supressió, és possible que l'arbre hagi de reparar per restaurar les propietats:
 
Quan s'elimina un node negre o se substitueix un node vermell per un node negre, pot sorgir una situació de doble negre.
    Anàlisi de casos per solucionar les supressions:    
 
    Cas 1: el germà és vermell    
Recoloreu el germà i el pare i feu una rotació.
    Cas 2: el germà és negre amb nens negres    
Recoloreu el germà al vermell i traslladeu el problema als pares.
    Cas 3: el germà és negre amb almenys un nen vermell    
Gira i torna a pintar per solucionar el problema del doble negre.
Implementació de l'arbre vermell-negre:
Aquí hi ha una implementació detallada d'un arbre vermell-negre que inclou funcions d'inserció, cerca i rotació:
C++dret;  x->dreta = y->esquerra;  if (y->esquerra != NIL) { y->esquerra->pare = x;  } y->parent = x->parent;  if (x->parent == nullptr) { arrel = y;  } else if (x == x->pare->esquerra) { x->pare->esquerra = y;  } else { x->parent->dret = y;  } y->esquerra = x;  x->parent = y;  } // Funció d'utilitat per fer la rotació dreta void rightRotate(Node* x) { Node* y = x->esquerra;  x->esquerra = y->dreta;  if (y->dreta != NIL) { y->dreta->pare = x;  } y->parent = x->parent;  if (x->parent == nullptr) { arrel = y;  } else if (x == x->pare->dret) { x->pare->dret = y;  } else { x->parent->esquerra = y;  } y->dreta = x;  x->parent = y;  } // Funció per corregir les propietats de l'arbre vermell-negre després de // inserció void fixInsert(Node* k) { while (k != arrel && k->parent->color == 'RED') { if (k->pare == k->pare->parent->esquerra) { Node* u = k->pare->pare->dreta; // oncle if (u->color == 'VERMELL') { k->parent->color = 'NEGRE';  u->color = 'NEGRE';  k->parent->parent->color = 'VERMELL';  k = k->pares->pares;  } else { if (k == k->parent->dret) { k = k->parent;  Girar a l'esquerra (k);  } k->parent->color = 'NEGRE';  k->parent->parent->color = 'VERMELL';  rightRotate(k->parent->parent);  } } else { Node* u = k->pare->pare->esquerra; // oncle if (u->color == 'VERMELL') { k->parent->color = 'NEGRE';  u->color = 'NEGRE';  k->parent->parent->color = 'VERMELL';  k = k->pares->pares;  } else { if (k == k->parent->esquerra) { k = k->parent;  Girar a la dreta (k);  } k->parent->color = 'NEGRE';  k->parent->parent->color = 'VERMELL';  leftRotate(k->pare->pare);  } } } arrel->color = 'NEGRE';  } // Funció d'ajuda per a la travessa en ordre void inorderHelper(Node* node) { if (node ​​!= NIL) { inorderHelper(node->esquerra);  cout<< node->dades<< ' ';  inorderHelper(node->dret);  } } // Funció auxiliar de cerca Node* searchHelper (Node* node, int dades) { if (node ​​== NIL || dades == node->dades) { retorn node;  } si (dades< node->dades) { return searchHelper (node->esquerra, dades);  } retorna l'Ajudant de cerca (node->dreta, dades);  } public: // Constructor RedBlackTree () { NIL = nou Node (0);  NIL->color = 'NEGRE';  NIL->esquerra = NIL->dreta = NIL;  arrel = NIL;  } // Insereix la funció void insert(in data) { Node* new_node = new Node (dades);  nou_node->esquerra = NIL;  nou_node->dreta = NIL;  Node* pare = nullptr;  Node* actual = arrel;  // BST inserit mentre (actual != NIL) { pare = actual;  if (nou_node->dades< current->dades) { actual = actual->esquerra;  } else { actual = actual->dreta;  } } nou_node->parent = pare;  if (parent == nullptr) { arrel = nou_node;  } else if (nou_node->dades< parent->dades) { pare->esquerra = nou_node;  } else { pare->dreta = nou_node;  } if (nou_node->parent == nullptr) { nou_node->color = 'BLACK';  tornar;  } if (nou_node->parent->parent == nullptr) { retorn;  } fixInsert(nou_node);  } // Inorder traversal void inorder() { inorderHelper(arrel); } // Funció de cerca Node* search(int data) { return searchHelper(arrel, dades);  }}; int main() { RedBlackTree rbt;  // Inserint elements rbt.insert(10);  rbt.insert(20);  rbt.insert(30);  rbt.insert(15);  // Inordre travessa 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; }>
  
Avantatges dels arbres vermells i negres:
    Equilibrat:    Els arbres vermell-negre s'autoequilibren, és a dir, mantenen automàticament un equilibri entre les altures dels subarbres esquerre i dret. Això assegura que les operacions de cerca, inserció i supressió triguen O(log n) temps en el pitjor dels casos.
    Cerca, inserció i supressió eficients:    A causa de la seva estructura equilibrada, els arbres vermells-negres ofereixen operacions eficients. La cerca, la inserció i la supressió requereixen temps O(log n) en el pitjor dels casos.
    Fàcil d'implementar:    Les regles per mantenir les propietats de l'arbre vermell-negre són relativament simples i senzilles d'implementar.
    Àmpliament utilitzat:    Els arbres vermells i negres són una opció popular per implementar diverses estructures de dades, com ara mapes, conjunts i cues de prioritat.
Desavantatges dels arbres vermells i negres:
    Més complex que altres arbres equilibrats:    En comparació amb arbres equilibrats més simples com els arbres AVL, els arbres vermells-negres tenen regles d'inserció i supressió més complexes.
    Càrrec constant:    Mantenir les propietats de l'arbre vermell-negre afegeix una petita sobrecàrrega a cada operació d'inserció i supressió.
    No és òptim per a tots els casos d'ús:    Tot i que és eficient per a la majoria de les operacions, els arbres vermells i negres poden no ser la millor opció per a aplicacions on es requereixen insercions i supressions freqüents, ja que la sobrecàrrega constant pot arribar a ser significativa.
Aplicacions dels arbres vermells i negres:
    Implementació de mapes i conjunts:    Els arbres vermells i negres s'utilitzen sovint per implementar mapes i conjunts, on la cerca, la inserció i la supressió eficients són crucials.
    Cues de prioritat:    Els arbres vermell-negre es poden utilitzar per implementar cues de prioritat, on els elements s'ordenen en funció de la seva prioritat.
    Sistemes de fitxers:    Els arbres vermells i negres s'utilitzen en alguns sistemes de fitxers per gestionar estructures de fitxers i directoris.
    Bases de dades en memòria:    Els arbres vermells i negres de vegades s'utilitzen a les bases de dades a la memòria per emmagatzemar i recuperar dades de manera eficient.
    Desenvolupament de gràfics i jocs:    Els arbres vermells i negres es poden utilitzar en gràfics i jocs desenvolupament per a tasques com la detecció de col·lisions i la recerca de camins.
Preguntes freqüents (FAQ) sobre Red-Black Tree:
1. Què és un arbre vermell-negre?
 
Un arbre vermell-negre és un arbre de cerca binari d'autoequilibri que manté un equilibri entre les altures dels seus subarbres esquerre i dret. Això assegura que les operacions de cerca, inserció i supressió triguen O(log n) temps en el pitjor dels casos. Els arbres vermells-negres s'utilitzen àmpliament en diverses aplicacions on es requereixen estructures de dades eficients.
 
2. Com manté l'equilibri un arbre vermell-negre?
 
Els arbres vermell-negre mantenen el seu equilibri aplicant regles específiques sobre els colors dels nodes (VERMELL o NEGRE) i les relacions entre ells. Aquestes regles asseguren que l'arbre es mantingui equilibrat i que la diferència d'alçada entre els subarbres esquerre i dret sigui com a màxim d'1.
un objecte en java
 
3. Quins són els avantatges d'utilitzar un arbre vermell-negre?
 
    Equilibrat:    Els arbres vermell-negre s'autoequilibren, garantint operacions eficients de cerca, inserció i supressió.
    Eficient:    Ofereixen complexitat temporal O(log n) per a la majoria de les operacions.
    Fàcil d'implementar:    Les regles per mantenir les propietats de l'arbre vermell-negre són relativament senzilles.
    Àmpliament utilitzat:    Són una opció popular per implementar diverses estructures de dades i algorismes.
4. Quins són els desavantatges d'utilitzar un arbre vermell-negre?
 
En comparació amb arbres equilibrats més simples com els arbres AVL, els arbres vermells-negres tenen regles d'inserció i supressió més complexes.
Mantenir les propietats de l'arbre vermell-negre afegeix una petita sobrecàrrega a cada operació d'inserció i supressió.
Per a aplicacions amb insercions i supressions freqüents, altres estructures d'arbre equilibrades poden ser més adequades.
5. Quines són algunes de les aplicacions habituals dels arbres vermells-negres?
 
Implementació de mapes i conjunts
Cues de prioritat
Sistemes de fitxers
Bases de dades en memòria
Desenvolupament de gràfics i jocs (detecció de col·lisions, recerca de camins)
    Articles relacionats:    
 Definició i significat d'arbre vermell-negre a DSA 
 Arbres de cerca binaris d'autoequilibri 
 Arbre negre vermell vs Arbre AVL 
 Quina diferència hi ha entre Heap i Red-Black Tree? 
 Inserció en arbre vermell-negre 
 Eliminació a l'arbre vermell-negre 
 Arbres vermell-negres | Inserció de dalt a baix