Drzewo czerwono-czarne

W tym samouczku dowiesz się, czym jest czerwono-czarne drzewo. Znajdziesz również działające przykłady różnych operacji wykonywanych na czerwono-czarnym drzewie w językach C, C ++, Java i Python.

Drzewo czerwono-czarne jest samo-równoważącym się drzewem wyszukiwania binarnego, w którym każdy węzeł zawiera dodatkowy bit oznaczający kolor węzła, czerwony lub czarny.

Czerwono-czarne drzewo spełnia następujące właściwości:

  1. Właściwość czerwony / czarny: każdy węzeł jest kolorowy, czerwony lub czarny.
  2. Właściwość korzenia: korzeń jest czarny.
  3. Właściwość liścia: każdy liść (NIL) jest czarny.
  4. Właściwość czerwona: Jeśli czerwony węzeł ma dzieci, dzieci są zawsze czarne.
  5. Właściwość głębokości: dla każdego węzła każda prosta ścieżka z tego węzła do dowolnego z jego liści potomnych ma tę samą głębię czerni (liczba czarnych węzłów).

Przykładem czerwono-czarnego drzewa jest:

Czerwone czarne drzewo

Każdy węzeł ma następujące atrybuty:

  • kolor
  • klucz
  • leftChild
  • rightChild
  • rodzic (z wyjątkiem węzła głównego)

W jaki sposób czerwono-czarne drzewo zachowuje zdolność równoważenia się?

Kolor czerwono-czarny służy do balansowania drzewa.

Ograniczenia nałożone na kolory węzłów zapewniają, że każda prosta ścieżka od korzenia do liścia nie jest więcej niż dwa razy dłuższa niż każda inna taka ścieżka. Pomaga w utrzymaniu samobalansowania się czerwono-czarnego drzewa.

Operacje na czerwono-czarnym drzewie

Różne operacje, które można wykonać na czerwono-czarnym drzewie to:

Obracanie poddrzew w czerwono-czarnym drzewie

Podczas operacji rotacji pozycje węzłów poddrzewa są zamieniane.

Operacja obracania służy do zachowania właściwości czerwono-czarnego drzewa, gdy zostaną naruszone przez inne operacje, takie jak wstawianie i usuwanie.

Istnieją dwa rodzaje obrotów:

Obrót w lewo

Przy rotacji w lewo rozmieszczenie węzłów po prawej stronie jest przekształcane w układy na lewym węźle.

Algorytm

  1. Niech początkowe drzewo będzie: Drzewo początkowe
  2. Jeśli y ma lewe poddrzewo, przypisz x jako rodzica lewego poddrzewa y. Przypisz x jako rodzica lewego poddrzewa y
  3. Jeśli rodzicem x jest NULL, utwórz y jako korzeń drzewa.
  4. W przeciwnym razie, jeśli x jest lewym dzieckiem p, zrób y jako lewe dziecko p.
  5. W przeciwnym razie przypisz y jako prawe dziecko p. Zmień rodzica x na rodzica y
  6. Uczyń y jako rodzic x. Przypisz y jako rodzica x.

Obrót w prawo

Przy rotacji w prawo rozmieszczenie węzłów po lewej stronie jest przekształcane w układy w węźle prawym.

  1. Niech początkowe drzewo będzie: Drzewo początkowe
  2. Jeśli x ma prawe poddrzewo, przypisz y jako rodzica prawego poddrzewa x. Przypisz y jako rodzica prawego poddrzewa x
  3. Jeśli rodzicem y jest NULL, utwórz x jako korzeń drzewa.
  4. W przeciwnym razie, jeśli y jest właściwym dzieckiem swojego rodzica p, uczyń x jako prawe dziecko p.
  5. W przeciwnym razie przypisz x jako lewe dziecko p. Przypisz rodzica y jako rodzica x
  6. Niech x będzie rodzicem y. Przypisz x jako rodzica y

Obrót w lewo-w prawo i w prawo-w lewo

W rotacji lewo-prawo aranżacje są najpierw przesuwane w lewo, a następnie w prawo.

  1. Wykonaj obrót w lewo na xy. Obrót w lewo xy
  2. Wykonaj prawy obrót na yz. Obróć w prawo zy

W rotacji prawo-lewo aranżacje są najpierw przesuwane w prawo, a następnie w lewo.

  1. Wykonaj prawą rotację na xy. Obrót w prawo xy
  2. Wykonaj obrót w lewo na zy. Obrót w lewo zy

Wstawianie elementu do czerwono-czarnego drzewa

Podczas wstawiania nowego węzła, nowy węzeł jest zawsze wstawiany jako węzeł RED. Po wstawieniu nowego węzła, jeśli drzewo narusza właściwości drzewa czerwono-czarnego, to wykonujemy następujące operacje.

  1. Ponownie koloruj
  2. Obrót

Algorytm wstawiania węzła

Aby wstawić nowy element do czerwono-czarnego drzewa, należy wykonać następujące kroki:

  1. Niech y będzie liściem (tj. NIL), A x będzie korzeniem drzewa.
  2. Sprawdź, czy drzewo jest puste (tj. Czy x jest NIL). Jeśli tak, wstaw newNode jako węzeł główny i pokoloruj go na czarno.
  3. W przeciwnym razie powtórz kroki następujące kroki, aż NILosiągniesz liść ( ).
    1. Porównaj newKey z rootKey.
    2. Jeśli newKey jest większy niż rootKey, przejdź przez prawe poddrzewo.
    3. W przeciwnym razie przechodzą przez lewe poddrzewo.
  4. Przypisz rodzica liścia jako rodzica newNode.
  5. Jeśli leafKey jest większy niż newKey, utwórz newNode jako rightChild.
  6. W przeciwnym razie utwórz newNode jako leftChild.
  7. Przypisz NULLdo lewej i prawej strony Dziecko nowego węzła.
  8. Przypisz CZERWONY kolor do newNode.
  9. Wywołaj algorytm InsertFix, aby zachować właściwość czerwono-czarnego drzewa w przypadku naruszenia.

Dlaczego nowo wstawione węzły są zawsze czerwone w czerwono-czarnym drzewie?

Dzieje się tak, ponieważ wstawienie czerwonego węzła nie narusza właściwości głębokości czerwono-czarnego drzewa.

Jeśli dołączysz czerwony węzeł do czerwonego węzła, reguła zostanie naruszona, ale łatwiej jest rozwiązać ten problem niż problem wprowadzony przez naruszenie właściwości depth.

Algorytm zachowania właściwości czerwono-czarny po wstawieniu

Ten algorytm jest używany do zachowania właściwości czerwono-czarnego drzewa, jeśli wstawienie newNode narusza tę właściwość.

  1. Wykonaj następujące czynności, gdy rodzic newNode p jest CZERWONY.
  2. Jeśli p jest lewym dzieckiem dziadka gP z z, wykonaj następujące czynności.
    Przypadek I:
    1. Jeśli kolor prawego dziecka gP z z jest CZERWONY, ustaw kolor obu dzieci gP na CZARNY, a kolor gP na CZERWONY.
    2. Przypisz GP do newNode.
      Przypadek II:
    3. W przeciwnym razie, jeśli newNode jest właściwym dzieckiem p, to przypisz p do newNode.
    4. Obróć w lewo newNode.
      Przypadek III:
    5. Ustaw kolor p na CZARNY, a kolor gP na CZERWONY.
    6. Obrót w prawo gstr.
  3. W przeciwnym razie wykonaj następujące czynności.
    1. Jeśli kolor lewego dziecka gP z z jest CZERWONY, ustaw kolor obu dzieci gP na CZARNY, a kolor gP na CZERWONY.
    2. Przypisz GP do newNode.
    3. W przeciwnym razie, jeśli newNode jest lewym dzieckiem p, przypisz p do newNode i obróć w prawo newNode.
    4. Ustaw kolor p na CZARNY, a kolor gP na CZERWONY.
    5. Obrót w lewo gstr.
  4. Ustaw korzeń drzewa jako CZARNY.

Usuwanie elementu z czerwono-czarnego drzewa

Ta operacja usuwa węzeł z drzewa. Po usunięciu węzła właściwość czerwono-czarna jest ponownie zachowywana.

Algorytm usuwania węzła

  1. Zapisz kolor nodeToBeDeleted w origrinalColor.
  2. Jeśli lewe dziecko nodeToBeDeleted to NULL
    1. Przypisz prawe dziecko nodeToBeDeleted do x.
    2. Transplant nodeToBeDeleted with x.
  3. W przeciwnym razie, jeśli prawe dziecko nodeToBeDeleted to NULL
    1. Przypisz lewe dziecko nodeToBeDeleted do x.
    2. Transplant nodeToBeDeleted with x.
  4. Jeszcze
    1. Przypisz minimum prawego poddrzewa noteToBeDeleted do y.
    2. Zapisz kolor y w originalColor.
    3. Przypisz prawe Dziecko y do x.
    4. Jeśli y jest dzieckiem nodeToBeDeleted, ustaw rodzica x jako y.
    5. W przeciwnym razie przeszczep y prawe Dziecko.
    6. Transplant nodeToBeDeleted with y.
    7. Ustaw kolor y za pomocą originalColor.
  5. Jeśli oryginał jest CZARNY, wywołaj DeleteFix (x).

Algorytm zachowania właściwości Czerwony-Czarny po usunięciu

Ten algorytm jest implementowany po usunięciu czarnego węzła, ponieważ narusza on właściwość głębi czerni drzewa czerwono-czarnego.

To naruszenie jest korygowane przez założenie, że węzeł x (który zajmuje pierwotną pozycję y) ma dodatkową czarną. To sprawia, że ​​węzeł x nie jest ani czerwony, ani czarny. Jest albo podwójnie czarny, albo czarno-czerwony. Narusza to właściwości czerwono-czarne.

Jednak atrybut koloru x nie jest zmieniany, a dodatkowa czerń jest reprezentowana przez x wskazujące na węzeł.

Dodatkową czerń można usunąć, jeśli

  1. Dociera do węzła głównego.
  2. Jeśli x wskazuje na czerwono-czarny węzeł. W tym przypadku x ma kolor czarny.
  3. Wykonywane są odpowiednie rotacje i przebarwienia.

Poniższy algorytm zachowuje właściwości czerwono-czarnego drzewa.

  1. Wykonuj następujące czynności, aż x nie będzie korzeniem drzewa, a kolor x będzie CZARNY
  2. Jeśli x jest lewym dzieckiem swojego rodzica, to
    1. Przypisz w do rodzeństwa x.
    2. Jeśli prawe dziecko rodzica x jest CZERWONE,
      przypadek I:
      1. Ustaw kolor prawego dziecka rodzica x jako CZARNY.
      2. Ustaw kolor rodzica x na CZERWONY.
      3. Obróć w lewo rodzica x.
      4. Przypisz rightChild rodzica x do w.
    3. Jeśli kolor prawej i lewej strony dziecka w jest CZARNY,
      przypadek II:
      1. Ustaw kolor w jako CZERWONY
      2. Przypisz rodzica x do x.
    4. W przeciwnym razie, jeśli kolor po prawej stronie dziecka w jest CZARNY.
      Przypadek III:
      1. Ustaw kolor lewego Dziecka w jako CZARNY
      2. Ustaw kolor w jako CZERWONY
      3. Obrót w prawo w.
      4. Przypisz rightChild rodzica x do w.
    5. Jeśli którykolwiek z powyższych przypadków nie wystąpi, wykonaj następujące czynności.
      Przypadek IV:
      1. Ustaw kolor w jako kolor rodzica x.
      2. Ustaw kolor rodzica x jako CZARNY.
      3. Ustaw kolor prawego dziecka w jako CZARNY.
      4. Obróć w lewo rodzica x.
      5. Ustaw x jako korzeń drzewa.
  3. W przeciwnym razie to samo, co powyżej, ze zmianą prawej strony na lewą i odwrotnie.
  4. Ustaw kolor x jako CZARNY.

Więcej wyjaśnień wraz z przykładami można znaleźć w operacjach wstawiania i usuwania.

Przykłady w Pythonie, Javie i C / C ++

Python Java C C ++ 
 # Implementing Red-Black Tree in Python import sys # Node creation class Node(): def __init__(self, item): self.item = item self.parent = None self.left = None self.right = None self.color = 1 class RedBlackTree(): def __init__(self): self.TNULL = Node(0) self.TNULL.color = 0 self.TNULL.left = None self.TNULL.right = None self.root = self.TNULL # Preorder def pre_order_helper(self, node): if node != TNULL: sys.stdout.write(node.item + " ") self.pre_order_helper(node.left) self.pre_order_helper(node.right) # Inorder def in_order_helper(self, node): if node != TNULL: self.in_order_helper(node.left) sys.stdout.write(node.item + " ") self.in_order_helper(node.right) # Postorder def post_order_helper(self, node): if node != TNULL: self.post_order_helper(node.left) self.post_order_helper(node.right) sys.stdout.write(node.item + " ") # Search the tree def search_tree_helper(self, node, key): if node == TNULL or key == node.item: return node if key < node.item: return self.search_tree_helper(node.left, key) return self.search_tree_helper(node.right, key) # Balancing the tree after deletion def delete_fix(self, x): while x != self.root and x.color == 0: if x == x.parent.left: s = x.parent.right if s.color == 1: s.color = 0 x.parent.color = 1 self.left_rotate(x.parent) s = x.parent.right if s.left.color == 0 and s.right.color == 0: s.color = 1 x = x.parent else: if s.right.color == 0: s.left.color = 0 s.color = 1 self.right_rotate(s) s = x.parent.right s.color = x.parent.color x.parent.color = 0 s.right.color = 0 self.left_rotate(x.parent) x = self.root else: s = x.parent.left if s.color == 1: s.color = 0 x.parent.color = 1 self.right_rotate(x.parent) s = x.parent.left if s.right.color == 0 and s.right.color == 0: s.color = 1 x = x.parent else: if s.left.color == 0: s.right.color = 0 s.color = 1 self.left_rotate(s) s = x.parent.left s.color = x.parent.color x.parent.color = 0 s.left.color = 0 self.right_rotate(x.parent) x = self.root x.color = 0 def __rb_transplant(self, u, v): if u.parent == None: self.root = v elif u == u.parent.left: u.parent.left = v else: u.parent.right = v v.parent = u.parent # Node deletion def delete_node_helper(self, node, key): z = self.TNULL while node != self.TNULL: if node.item == key: z = node if node.item <= key: node = node.right else: node = node.left if z == self.TNULL: print("Cannot find key in the tree") return y = z y_original_color = y.color if z.left == self.TNULL: x = z.right self.__rb_transplant(z, z.right) elif (z.right == self.TNULL): x = z.left self.__rb_transplant(z, z.left) else: y = self.minimum(z.right) y_original_color = y.color x = y.right if y.parent == z: x.parent = y else: self.__rb_transplant(y, y.right) y.right = z.right y.right.parent = y self.__rb_transplant(z, y) y.left = z.left y.left.parent = y y.color = z.color if y_original_color == 0: self.delete_fix(x) # Balance the tree after insertion def fix_insert(self, k): while k.parent.color == 1: if k.parent == k.parent.parent.right: u = k.parent.parent.left if u.color == 1: u.color = 0 k.parent.color = 0 k.parent.parent.color = 1 k = k.parent.parent else: if k == k.parent.left: k = k.parent self.right_rotate(k) k.parent.color = 0 k.parent.parent.color = 1 self.left_rotate(k.parent.parent) else: u = k.parent.parent.right if u.color == 1: u.color = 0 k.parent.color = 0 k.parent.parent.color = 1 k = k.parent.parent else: if k == k.parent.right: k = k.parent self.left_rotate(k) k.parent.color = 0 k.parent.parent.color = 1 self.right_rotate(k.parent.parent) if k == self.root: break self.root.color = 0 # Printing the tree def __print_helper(self, node, indent, last): if node != self.TNULL: sys.stdout.write(indent) if last: sys.stdout.write("R----") indent += " " else: sys.stdout.write("L----") indent += "| " s_color = "RED" if node.color == 1 else "BLACK" print(str(node.item) + "(" + s_color + ")") self.__print_helper(node.left, indent, False) self.__print_helper(node.right, indent, True) def preorder(self): self.pre_order_helper(self.root) def inorder(self): self.in_order_helper(self.root) def postorder(self): self.post_order_helper(self.root) def searchTree(self, k): return self.search_tree_helper(self.root, k) def minimum(self, node): while node.left != self.TNULL: node = node.left return node def maximum(self, node): while node.right != self.TNULL: node = node.right return node def successor(self, x): if x.right != self.TNULL: return self.minimum(x.right) y = x.parent while y != self.TNULL and x == y.right: x = y y = y.parent return y def predecessor(self, x): if (x.left != self.TNULL): return self.maximum(x.left) y = x.parent while y != self.TNULL and x == y.left: x = y y = y.parent return y def left_rotate(self, x): y = x.right x.right = y.left if y.left != self.TNULL: y.left.parent = x y.parent = x.parent if x.parent == None: self.root = y elif x == x.parent.left: x.parent.left = y else: x.parent.right = y y.left = x x.parent = y def right_rotate(self, x): y = x.left x.left = y.right if y.right != self.TNULL: y.right.parent = x y.parent = x.parent if x.parent == None: self.root = y elif x == x.parent.right: x.parent.right = y else: x.parent.left = y y.right = x x.parent = y def insert(self, key): node = Node(key) node.parent = None node.item = key node.left = self.TNULL node.right = self.TNULL node.color = 1 y = None x = self.root while x != self.TNULL: y = x if node.item < x.item: x = x.left else: x = x.right node.parent = y if y == None: self.root = node elif node.item < y.item: y.left = node else: y.right = node if node.parent == None: node.color = 0 return if node.parent.parent == None: return self.fix_insert(node) def get_root(self): return self.root def delete_node(self, item): self.delete_node_helper(self.root, item) def print_tree(self): self.__print_helper(self.root, "", True) if __name__ == "__main__": bst = RedBlackTree() bst.insert(55) bst.insert(40) bst.insert(65) bst.insert(60) bst.insert(75) bst.insert(57) bst.print_tree() print("After deleting an element") bst.delete_node(40) bst.print_tree() 
 // Implementing Red-Black Tree in Java class Node ( int data; Node parent; Node left; Node right; int color; ) public class RedBlackTree ( private Node root; private Node TNULL; // Preorder private void preOrderHelper(Node node) ( if (node != TNULL) ( System.out.print(node.data + " "); preOrderHelper(node.left); preOrderHelper(node.right); ) ) // Inorder private void inOrderHelper(Node node) ( if (node != TNULL) ( inOrderHelper(node.left); System.out.print(node.data + " "); inOrderHelper(node.right); ) ) // Post order private void postOrderHelper(Node node) ( if (node != TNULL) ( postOrderHelper(node.left); postOrderHelper(node.right); System.out.print(node.data + " "); ) ) // Search the tree private Node searchTreeHelper(Node node, int key) ( if (node == TNULL || key == node.data) ( return node; ) if (key < node.data) ( return searchTreeHelper(node.left, key); ) return searchTreeHelper(node.right, key); ) // Balance the tree after deletion of a node private void fixDelete(Node x) ( Node s; while (x != root && x.color == 0) ( if (x == x.parent.left) ( s = x.parent.right; if (s.color == 1) ( s.color = 0; x.parent.color = 1; leftRotate(x.parent); s = x.parent.right; ) if (s.left.color == 0 && s.right.color == 0) ( s.color = 1; x = x.parent; ) else ( if (s.right.color == 0) ( s.left.color = 0; s.color = 1; rightRotate(s); s = x.parent.right; ) s.color = x.parent.color; x.parent.color = 0; s.right.color = 0; leftRotate(x.parent); x = root; ) ) else ( s = x.parent.left; if (s.color == 1) ( s.color = 0; x.parent.color = 1; rightRotate(x.parent); s = x.parent.left; ) if (s.right.color == 0 && s.right.color == 0) ( s.color = 1; x = x.parent; ) else ( if (s.left.color == 0) ( s.right.color = 0; s.color = 1; leftRotate(s); s = x.parent.left; ) s.color = x.parent.color; x.parent.color = 0; s.left.color = 0; rightRotate(x.parent); x = root; ) ) ) x.color = 0; ) private void rbTransplant(Node u, Node v) ( if (u.parent == null) ( root = v; ) else if (u == u.parent.left) ( u.parent.left = v; ) else ( u.parent.right = v; ) v.parent = u.parent; ) private void deleteNodeHelper(Node node, int key) ( Node z = TNULL; Node x, y; while (node != TNULL) ( if (node.data == key) ( z = node; ) if (node.data <= key) ( node = node.right; ) else ( node = node.left; ) ) if (z == TNULL) ( System.out.println("Couldn't find key in the tree"); return; ) y = z; int yOriginalColor = y.color; if (z.left == TNULL) ( x = z.right; rbTransplant(z, z.right); ) else if (z.right == TNULL) ( x = z.left; rbTransplant(z, z.left); ) else ( y = minimum(z.right); yOriginalColor = y.color; x = y.right; if (y.parent == z) ( x.parent = y; ) else ( rbTransplant(y, y.right); y.right = z.right; y.right.parent = y; ) rbTransplant(z, y); y.left = z.left; y.left.parent = y; y.color = z.color; ) if (yOriginalColor == 0) ( fixDelete(x); ) ) // Balance the node after insertion private void fixInsert(Node k) ( Node u; while (k.parent.color == 1) ( if (k.parent == k.parent.parent.right) ( u = k.parent.parent.left; if (u.color == 1) ( u.color = 0; k.parent.color = 0; k.parent.parent.color = 1; k = k.parent.parent; ) else ( if (k == k.parent.left) ( k = k.parent; rightRotate(k); ) k.parent.color = 0; k.parent.parent.color = 1; leftRotate(k.parent.parent); ) ) else ( u = k.parent.parent.right; if (u.color == 1) ( u.color = 0; k.parent.color = 0; k.parent.parent.color = 1; k = k.parent.parent; ) else ( if (k == k.parent.right) ( k = k.parent; leftRotate(k); ) k.parent.color = 0; k.parent.parent.color = 1; rightRotate(k.parent.parent); ) ) if (k == root) ( break; ) ) root.color = 0; ) private void printHelper(Node root, String indent, boolean last) ( if (root != TNULL) ( System.out.print(indent); if (last) ( System.out.print("R----"); indent += " "; ) else ( System.out.print("L----"); indent += "| "; ) String sColor = root.color == 1 ? "RED" : "BLACK"; System.out.println(root.data + "(" + sColor + ")"); printHelper(root.left, indent, false); printHelper(root.right, indent, true); ) ) public RedBlackTree() ( TNULL = new Node(); TNULL.color = 0; TNULL.left = null; TNULL.right = null; root = TNULL; ) public void preorder() ( preOrderHelper(this.root); ) public void inorder() ( inOrderHelper(this.root); ) public void postorder() ( postOrderHelper(this.root); ) public Node searchTree(int k) ( return searchTreeHelper(this.root, k); ) public Node minimum(Node node) ( while (node.left != TNULL) ( node = node.left; ) return node; ) public Node maximum(Node node) ( while (node.right != TNULL) ( node = node.right; ) return node; ) public Node successor(Node x) ( if (x.right != TNULL) ( return minimum(x.right); ) Node y = x.parent; while (y != TNULL && x == y.right) ( x = y; y = y.parent; ) return y; ) public Node predecessor(Node x) ( if (x.left != TNULL) ( return maximum(x.left); ) Node y = x.parent; while (y != TNULL && x == y.left) ( x = y; y = y.parent; ) return y; ) public void leftRotate(Node x) ( Node y = x.right; x.right = y.left; if (y.left != TNULL) ( y.left.parent = x; ) y.parent = x.parent; if (x.parent == null) ( this.root = y; ) else if (x == x.parent.left) ( x.parent.left = y; ) else ( x.parent.right = y; ) y.left = x; x.parent = y; ) public void rightRotate(Node x) ( Node y = x.left; x.left = y.right; if (y.right != TNULL) ( y.right.parent = x; ) y.parent = x.parent; if (x.parent == null) ( this.root = y; ) else if (x == x.parent.right) ( x.parent.right = y; ) else ( x.parent.left = y; ) y.right = x; x.parent = y; ) public void insert(int key) ( Node node = new Node(); node.parent = null; node.data = key; node.left = TNULL; node.right = TNULL; node.color = 1; Node y = null; Node x = this.root; while (x != TNULL) ( y = x; if (node.data < x.data) ( x = x.left; ) else ( x = x.right; ) ) node.parent = y; if (y == null) ( root = node; ) else if (node.data < y.data) ( y.left = node; ) else ( y.right = node; ) if (node.parent == null) ( node.color = 0; return; ) if (node.parent.parent == null) ( return; ) fixInsert(node); ) public Node getRoot() ( return this.root; ) public void deleteNode(int data) ( deleteNodeHelper(this.root, data); ) public void printTree() ( printHelper(this.root, "", true); ) public static void main(String() args) ( RedBlackTree bst = new RedBlackTree(); bst.insert(55); bst.insert(40); bst.insert(65); bst.insert(60); bst.insert(75); bst.insert(57); bst.printTree(); System.out.println("After deleting:"); bst.deleteNode(40); bst.printTree(); ) )
 // Implementing Red-Black Tree in C #include #include enum nodeColor ( RED, BLACK ); struct rbNode ( int data, color; struct rbNode *link(2); ); struct rbNode *root = NULL; // Create a red-black tree struct rbNode *createNode(int data) ( struct rbNode *newnode; newnode = (struct rbNode *)malloc(sizeof(struct rbNode)); newnode->data = data; newnode->color = RED; newnode->link(0) = newnode->link(1) = NULL; return newnode; ) // Insert an node void insertion(int data) ( struct rbNode *stack(98), *ptr, *newnode, *xPtr, *yPtr; int dir(98), ht = 0, index; ptr = root; if (!root) ( root = createNode(data); return; ) stack(ht) = root; dir(ht++) = 0; while (ptr != NULL) ( if (ptr->data == data) ( printf("Duplicates Not Allowed!!"); return; ) index = (data - ptr->data)> 0 ? 1 : 0; stack(ht) = ptr; ptr = ptr->link(index); dir(ht++) = index; ) stack(ht - 1)->link(index) = newnode = createNode(data); while ((ht>= 3) && (stack(ht - 1)->color == RED)) ( if (dir(ht - 2) == 0) ( yPtr = stack(ht - 2)->link(1); if (yPtr != NULL && yPtr->color == RED) ( stack(ht - 2)->color = RED; stack(ht - 1)->color = yPtr->color = BLACK; ht = ht - 2; ) else ( if (dir(ht - 1) == 0) ( yPtr = stack(ht - 1); ) else ( xPtr = stack(ht - 1); yPtr = xPtr->link(1); xPtr->link(1) = yPtr->link(0); yPtr->link(0) = xPtr; stack(ht - 2)->link(0) = yPtr; ) xPtr = stack(ht - 2); xPtr->color = RED; yPtr->color = BLACK; xPtr->link(0) = yPtr->link(1); yPtr->link(1) = xPtr; if (xPtr == root) ( root = yPtr; ) else ( stack(ht - 3)->link(dir(ht - 3)) = yPtr; ) break; ) ) else ( yPtr = stack(ht - 2)->link(0); if ((yPtr != NULL) && (yPtr->color == RED)) ( stack(ht - 2)->color = RED; stack(ht - 1)->color = yPtr->color = BLACK; ht = ht - 2; ) else ( if (dir(ht - 1) == 1) ( yPtr = stack(ht - 1); ) else ( xPtr = stack(ht - 1); yPtr = xPtr->link(0); xPtr->link(0) = yPtr->link(1); yPtr->link(1) = xPtr; stack(ht - 2)->link(1) = yPtr; ) xPtr = stack(ht - 2); yPtr->color = BLACK; xPtr->color = RED; xPtr->link(1) = yPtr->link(0); yPtr->link(0) = xPtr; if (xPtr == root) ( root = yPtr; ) else ( stack(ht - 3)->link(dir(ht - 3)) = yPtr; ) break; ) ) ) root->color = BLACK; ) // Delete a node void deletion(int data) ( struct rbNode *stack(98), *ptr, *xPtr, *yPtr; struct rbNode *pPtr, *qPtr, *rPtr; int dir(98), ht = 0, diff, i; enum nodeColor color; if (!root) ( printf("Tree not available"); return; ) ptr = root; while (ptr != NULL) ( if ((data - ptr->data) == 0) break; diff = (data - ptr->data)> 0 ? 1 : 0; stack(ht) = ptr; dir(ht++) = diff; ptr = ptr->link(diff); ) if (ptr->link(1) == NULL) ( if ((ptr == root) && (ptr->link(0) == NULL)) ( free(ptr); root = NULL; ) else if (ptr == root) ( root = ptr->link(0); free(ptr); ) else ( stack(ht - 1)->link(dir(ht - 1)) = ptr->link(0); ) ) else ( xPtr = ptr->link(1); if (xPtr->link(0) == NULL) ( xPtr->link(0) = ptr->link(0); color = xPtr->color; xPtr->color = ptr->color; ptr->color = color; if (ptr == root) ( root = xPtr; ) else ( stack(ht - 1)->link(dir(ht - 1)) = xPtr; ) dir(ht) = 1; stack(ht++) = xPtr; ) else ( i = ht++; while (1) ( dir(ht) = 0; stack(ht++) = xPtr; yPtr = xPtr->link(0); if (!yPtr->link(0)) break; xPtr = yPtr; ) dir(i) = 1; stack(i) = yPtr; if (i> 0) stack(i - 1)->link(dir(i - 1)) = yPtr; yPtr->link(0) = ptr->link(0); xPtr->link(0) = yPtr->link(1); yPtr->link(1) = ptr->link(1); if (ptr == root) ( root = yPtr; ) color = yPtr->color; yPtr->color = ptr->color; ptr->color = color; ) ) if (ht color == BLACK) ( while (1) ( pPtr = stack(ht - 1)->link(dir(ht - 1)); if (pPtr && pPtr->color == RED) ( pPtr->color = BLACK; break; ) if (ht link(1); if (!rPtr) break; if (rPtr->color == RED) ( stack(ht - 1)->color = RED; rPtr->color = BLACK; stack(ht - 1)->link(1) = rPtr->link(0); rPtr->link(0) = stack(ht - 1); if (stack(ht - 1) == root) ( root = rPtr; ) else ( stack(ht - 2)->link(dir(ht - 2)) = rPtr; ) dir(ht) = 0; stack(ht) = stack(ht - 1); stack(ht - 1) = rPtr; ht++; rPtr = stack(ht - 1)->link(1); ) if ((!rPtr->link(0) || rPtr->link(0)->color == BLACK) && (!rPtr->link(1) || rPtr->link(1)->color == BLACK)) ( rPtr->color = RED; ) else ( if (!rPtr->link(1) || rPtr->link(1)->color == BLACK) ( qPtr = rPtr->link(0); rPtr->color = RED; qPtr->color = BLACK; rPtr->link(0) = qPtr->link(1); qPtr->link(1) = rPtr; rPtr = stack(ht - 1)->link(1) = qPtr; ) rPtr->color = stack(ht - 1)->color; stack(ht - 1)->color = BLACK; rPtr->link(1)->color = BLACK; stack(ht - 1)->link(1) = rPtr->link(0); rPtr->link(0) = stack(ht - 1); if (stack(ht - 1) == root) ( root = rPtr; ) else ( stack(ht - 2)->link(dir(ht - 2)) = rPtr; ) break; ) ) else ( rPtr = stack(ht - 1)->link(0); if (!rPtr) break; if (rPtr->color == RED) ( stack(ht - 1)->color = RED; rPtr->color = BLACK; stack(ht - 1)->link(0) = rPtr->link(1); rPtr->link(1) = stack(ht - 1); if (stack(ht - 1) == root) ( root = rPtr; ) else ( stack(ht - 2)->link(dir(ht - 2)) = rPtr; ) dir(ht) = 1; stack(ht) = stack(ht - 1); stack(ht - 1) = rPtr; ht++; rPtr = stack(ht - 1)->link(0); ) if ((!rPtr->link(0) || rPtr->link(0)->color == BLACK) && (!rPtr->link(1) || rPtr->link(1)->color == BLACK)) ( rPtr->color = RED; ) else ( if (!rPtr->link(0) || rPtr->link(0)->color == BLACK) ( qPtr = rPtr->link(1); rPtr->color = RED; qPtr->color = BLACK; rPtr->link(1) = qPtr->link(0); qPtr->link(0) = rPtr; rPtr = stack(ht - 1)->link(0) = qPtr; ) rPtr->color = stack(ht - 1)->color; stack(ht - 1)->color = BLACK; rPtr->link(0)->color = BLACK; stack(ht - 1)->link(0) = rPtr->link(1); rPtr->link(1) = stack(ht - 1); if (stack(ht - 1) == root) ( root = rPtr; ) else ( stack(ht - 2)->link(dir(ht - 2)) = rPtr; ) break; ) ) ht--; ) ) ) // Print the inorder traversal of the tree void inorderTraversal(struct rbNode *node) ( if (node) ( inorderTraversal(node->link(0)); printf("%d ", node->data); inorderTraversal(node->link(1)); ) return; ) // Driver code int main() ( int ch, data; while (1) ( printf("1. Insertion 2. Deletion"); printf("3. Traverse 4. Exit"); printf("Enter your choice:"); scanf("%d", &ch); switch (ch) ( case 1: printf("Enter the element to insert:"); scanf("%d", &data); insertion(data); break; case 2: printf("Enter the element to delete:"); scanf("%d", &data); deletion(data); break; case 3: inorderTraversal(root); printf(""); break; case 4: exit(0); default: printf("Not available"); break; ) printf(""); ) return 0; )
 // Implementing Red-Black Tree in C++ #include using namespace std; struct Node ( int data; Node *parent; Node *left; Node *right; int color; ); typedef Node *NodePtr; class RedBlackTree ( private: NodePtr root; NodePtr TNULL; void initializeNULLNode(NodePtr node, NodePtr parent) ( node->data = 0; node->parent = parent; node->left = nullptr; node->right = nullptr; node->color = 0; ) // Preorder void preOrderHelper(NodePtr node) ( if (node != TNULL) ( cout right); ) ) // Inorder void inOrderHelper(NodePtr node) ( if (node != TNULL) ( inOrderHelper(node->left); cout left); postOrderHelper(node->right); cout left, key); ) return searchTreeHelper(node->right, key); ) // For balancing the tree after deletion void deleteFix(NodePtr x) ( NodePtr s; while (x != root && x->color == 0) ( if (x == x->parent->left) ( s = x->parent->right; if (s->color == 1) ( s->color = 0; x->parent->color = 1; leftRotate(x->parent); s = x->parent->right; ) if (s->left->color == 0 && s->right->color == 0) ( s->color = 1; x = x->parent; ) else ( if (s->right->color == 0) ( s->left->color = 0; s->color = 1; rightRotate(s); s = x->parent->right; ) s->color = x->parent->color; x->parent->color = 0; s->right->color = 0; leftRotate(x->parent); x = root; ) ) else ( s = x->parent->left; if (s->color == 1) ( s->color = 0; x->parent->color = 1; rightRotate(x->parent); s = x->parent->left; ) if (s->right->color == 0 && s->right->color == 0) ( s->color = 1; x = x->parent; ) else ( if (s->left->color == 0) ( s->right->color = 0; s->color = 1; leftRotate(s); s = x->parent->left; ) s->color = x->parent->color; x->parent->color = 0; s->left->color = 0; rightRotate(x->parent); x = root; ) ) ) x->color = 0; ) void rbTransplant(NodePtr u, NodePtr v) ( if (u->parent == nullptr) ( root = v; ) else if (u == u->parent->left) ( u->parent->left = v; ) else ( u->parent->right = v; ) v->parent = u->parent; ) void deleteNodeHelper(NodePtr node, int key) ( NodePtr z = TNULL; NodePtr x, y; while (node != TNULL) ( if (node->data == key) ( z = node; ) if (node->data right; ) else ( node = node->left; ) ) if (z == TNULL) ( cout << "Key not found in the tree"  left == TNULL) ( x = z->right; rbTransplant(z, z->right); ) else if (z->right == TNULL) ( x = z->left; rbTransplant(z, z->left); ) else ( y = minimum(z->right); y_original_color = y->color; x = y->right; if (y->parent == z) ( x->parent = y; ) else ( rbTransplant(y, y->right); y->right = z->right; y->right->parent = y; ) rbTransplant(z, y); y->left = z->left; y->left->parent = y; y->color = z->color; ) delete z; if (y_original_color == 0) ( deleteFix(x); ) ) // For balancing the tree after insertion void insertFix(NodePtr k) ( NodePtr u; while (k->parent->color == 1) ( if (k->parent == k->parent->parent->right) ( u = k->parent->parent->left; if (u->color == 1) ( u->color = 0; k->parent->color = 0; k->parent->parent->color = 1; k = k->parent->parent; ) else ( if (k == k->parent->left) ( k = k->parent; rightRotate(k); ) k->parent->color = 0; k->parent->parent->color = 1; leftRotate(k->parent->parent); ) ) else ( u = k->parent->parent->right; if (u->color == 1) ( u->color = 0; k->parent->color = 0; k->parent->parent->color = 1; k = k->parent->parent; ) else ( if (k == k->parent->right) ( k = k->parent; leftRotate(k); ) k->parent->color = 0; k->parent->parent->color = 1; rightRotate(k->parent->parent); ) ) if (k == root) ( break; ) ) root->color = 0; ) void printHelper(NodePtr root, string indent, bool last) ( if (root != TNULL) ( cout << indent; if (last) ( cout << "R----"; indent += " "; ) else ( cout  right, indent, true); ) ) public: RedBlackTree() ( TNULL = new Node; TNULL->color = 0; TNULL->left = nullptr; TNULL->right = nullptr; root = TNULL; ) void preorder() ( preOrderHelper(this->root); ) void inorder() ( inOrderHelper(this->root); ) void postorder() ( postOrderHelper(this->root); ) NodePtr searchTree(int k) ( return searchTreeHelper(this->root, k); ) NodePtr minimum(NodePtr node) ( while (node->left != TNULL) ( node = node->left; ) return node; ) NodePtr maximum(NodePtr node) ( while (node->right != TNULL) ( node = node->right; ) return node; ) NodePtr successor(NodePtr x) ( if (x->right != TNULL) ( return minimum(x->right); ) NodePtr y = x->parent; while (y != TNULL && x == y->right) ( x = y; y = y->parent; ) return y; ) NodePtr predecessor(NodePtr x) ( if (x->left != TNULL) ( return maximum(x->left); ) NodePtr y = x->parent; while (y != TNULL && x == y->left) ( x = y; y = y->parent; ) return y; ) void leftRotate(NodePtr x) ( NodePtr y = x->right; x->right = y->left; if (y->left != TNULL) ( y->left->parent = x; ) y->parent = x->parent; if (x->parent == nullptr) ( this->root = y; ) else if (x == x->parent->left) ( x->parent->left = y; ) else ( x->parent->right = y; ) y->left = x; x->parent = y; ) void rightRotate(NodePtr x) ( NodePtr y = x->left; x->left = y->right; if (y->right != TNULL) ( y->right->parent = x; ) y->parent = x->parent; if (x->parent == nullptr) ( this->root = y; ) else if (x == x->parent->right) ( x->parent->right = y; ) else ( x->parent->left = y; ) y->right = x; x->parent = y; ) // Inserting a node void insert(int key) ( NodePtr node = new Node; node->parent = nullptr; node->data = key; node->left = TNULL; node->right = TNULL; node->color = 1; NodePtr y = nullptr; NodePtr x = this->root; while (x != TNULL) ( y = x; if (node->data data) ( x = x->left; ) else ( x = x->right; ) ) node->parent = y; if (y == nullptr) ( root = node; ) else if (node->data data) ( y->left = node; ) else ( y->right = node; ) if (node->parent == nullptr) ( node->color = 0; return; ) if (node->parent->parent == nullptr) ( return; ) insertFix(node); ) NodePtr getRoot() ( return this->root; ) void deleteNode(int data) ( deleteNodeHelper(this->root, data); ) void printTree() ( if (root) ( printHelper(this->root, "", true); ) ) ); int main() ( RedBlackTree bst; bst.insert(55); bst.insert(40); bst.insert(65); bst.insert(60); bst.insert(75); bst.insert(57); bst.printTree(); cout << endl << "After deleting" << endl; bst.deleteNode(40); bst.printTree(); )

Aplikacje w czerwono-czarnym drzewie

  1. Wdrażanie skończonych map
  2. Aby zaimplementować pakiety Java: java.util.TreeMapijava.util.TreeSet
  3. Aby zaimplementować standardowe biblioteki szablonów (STL) w C ++: multiset, map, multimap
  4. W jądrze Linux

Interesujące artykuły...