Red-Black Tree

src/helper/Enum/Color.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Src\helper\Enum;
+
+enum Color
+{
+    case Red;
+    case Black;
+}

src/helper/Enum/Direction.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Src\helper\Enum;
+
+enum Direction: string
+{
+    case Left = 'left';
+    case Right = 'right';
+
+    public function operation(string $operationName): string
+    {
+        return $operationName . $this->name;
+    }
+
+    public function opposite(): Direction
+    {
+        return match ($this) {
+            Direction::Left => Direction::Right,
+            Direction::Right => Direction::Left,
+        };
+    }
+}

src/helper/RedBlackNode.php

@@ -0,0 +1,153 @@
+<?php
+
+namespace Src\helper;
+
+use Src\helper\Enum\Color;
+use Src\helper\Enum\Direction;
+
+class RedBlackNode
+{
+    /**
+     * @param int $value
+     * @param RedBlackNode|null $parent
+     * @param Color $color
+     * @param RedBlackNode|null $left
+     * @param RedBlackNode|null $right
+     */
+    public function __construct(
+        private readonly int  $value,
+        private ?RedBlackNode $parent = null,
+        private Color         $color = Color::Red,
+        private ?RedBlackNode $left = null,
+        private ?RedBlackNode $right = null
+    ) {}
+
+    public function getValue(): int
+    {
+        return $this->value;
+    }
+
+    public function getParent(): ?RedBlackNode
+    {
+        return $this->parent;
+    }
+
+    public function setParent(?RedBlackNode $node): void
+    {
+        $this->parent = $node;
+    }
+
+    public function getColor(): Color
+    {
+        return $this->color;
+    }
+
+    public function setColor(Color $color): void
+    {
+        $this->color = $color;
+    }
+
+    public function getLeft(): ?RedBlackNode
+    {
+        return $this->left;
+    }
+
+    public function setLeft(?RedBlackNode $node): void
+    {
+        $this->left = $node;
+        $node?->setParent($this);
+    }
+
+    public function getRight(): ?RedBlackNode
+    {
+        return $this->right;
+    }
+
+    public function setRight(?RedBlackNode $node): void
+    {
+        $this->right = $node;
+        $node?->setParent($this);
+    }
+
+    /**
+     * Check if $this node is the child of its parents in $direction
+     *
+     * @param Direction $direction
+     * @return bool
+     */
+    public function isChild(Direction $direction): bool
+    {
+        if (!$this->parent) {
+            return false;
+        } elseif ($this->parent->{$direction->operation('get')}() === $this) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Returns the sibling of the parent of $this
+     *
+     * @return RedBlackNode|null
+     */
+    public function uncle(): ?RedBlackNode
+    {
+        if (!$this->parent || !$this->parent->getParent()) {
+            return null;
+        }
+        return $this->parent->sibling();
+    }
+
+    /**
+     * Return the opposite child of the parents to $this
+     *
+     * @return RedBlackNode|null
+     */
+    public function sibling(): ?RedBlackNode
+    {
+        if (!$this->parent) {
+            return null;
+        }
+        return $this->isChild(Direction::Left)
+            ? $this->parent->getRight()
+            : $this->parent->getLeft();
+    }
+
+    /**
+     * Rotate the subtree around $this in the $direction and updates relations
+     *
+     * @param RedBlackTree $tree
+     * @param Direction $direction
+     * @return void
+     */
+    public function rotate(RedBlackTree $tree, Direction $direction): void
+    {
+        if (!$this->{$direction->opposite()->value}) {
+            return;
+        }
+        $grandchild = $this->{$direction->opposite()->value}->{$direction->operation('get')}();
+        $this->updateParent($tree, $direction->opposite());
+        $this->{$direction->opposite()->value}->{$direction->operation('set')}($this);
+        $this->{$direction->opposite()->operation('set')}($grandchild);
+    }
+
+    /**
+     * Update the parent of the node to the child in the $direction
+     * should $this be root (both children checks null), update parent to null and set child in $direction as new root
+     *
+     * @param RedBlackTree $tree
+     * @param Direction $direction
+     * @return void
+     */
+    private function updateParent(RedBlackTree $tree, Direction $direction): void
+    {
+        if ($this->isChild(Direction::Left)) {
+            $this->parent->setLeft($this->{$direction->value});
+        } elseif ($this->isChild(Direction::Right)) {
+            $this->parent->setRight($this->{$direction->value});
+        } else {
+            $this->{$direction->value}->setParent(null);
+            $tree->setRoot($this->{$direction->value});
+        }
+    }
+}

src/helper/RedBlackTree.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace Src\helper;
+
+use Src\helper\Enum\Color;
+use Src\helper\Enum\Direction;
+
+class RedBlackTree
+{
+    /**
+     * @param RedBlackNode|null $root
+     */
+    public function __construct(private ?RedBlackNode $root = null) {}
+
+    public function getRoot(): ?RedBlackNode
+    {
+        return $this->root;
+    }
+
+    public function setRoot(RedBlackNode $node): void
+    {
+        $this->root = $node;
+    }
+
+    /**
+     * Inserts a new node with provided $value into the tree
+     *
+     * @param int $value
+     * @return void
+     */
+    public function insert(int $value): void
+    {
+        if ($this->root == null) {
+            $this->root = new RedBlackNode($value);
+            $this->root->setColor(Color::Black);
+            return;
+        }
+        $pointer = $this->binaryTreeInsert($this->root, $value);
+        do {
+            if ($pointer->getColor() == Color::Black) {
+                break;
+            }
+            if ($pointer->uncle() && $pointer->uncle()->getColor() == Color::Red) {
+                $pointer->getParent()->setColor(Color::Black);
+                $pointer->uncle()->setColor(Color::Black);
+                $pointer = $pointer->getParent()->getParent();
+                continue;
+            }
+            if ($pointer->getParent()->isChild(Direction::Left) && $pointer->isChild(Direction::Left)) {
+                $pointer->getParent()->getParent()->rotate($this, Direction::Right);
+                $pointer->getParent()->setColor(Color::Black);
+                $pointer->sibling()->setColor(Color::Red);
+                continue;
+            }
+            if ($pointer->getParent()->isChild(Direction::Left) && $pointer->isChild(Direction::Right)) {
+                $pointer->getParent()->rotate($this, Direction::Left);
+                $pointer->getParent()->rotate($this, Direction::Right);
+                $pointer->setColor(Color::Black);
+                $pointer->getRight()->setColor(Color::Red);
+                continue;
+            }
+            if ($pointer->getParent()->isChild(Direction::Right) && $pointer->isChild(Direction::Right)) {
+                $pointer->getParent()->getParent()->rotate($this, Direction::Left);
+                $pointer->getParent()->setColor(Color::Black);
+                $pointer->sibling()->setColor(Color::Red);
+                continue;
+            }
+            if ($pointer->getParent()->isChild(Direction::Right) && $pointer->isChild(Direction::Left)) {
+                $pointer->getParent()->rotate($this, Direction::Right);
+                $pointer->getParent()->rotate($this, Direction::Left);
+                $pointer->setColor(Color::Black);
+                $pointer->getLeft()->setColor(Color::Red);
+                $pointer->getParent()->setColor(Color::Black);
+                continue;
+            }
+            break;
+        } while ($pointer);
+    }
+
+    /**
+     * Delete the provided node from the tree
+     *
+     * @param RedBlackNode $node
+     * @return void
+     */
+    public function delete(RedBlackNode $node): void
+    {
+        $this->binaryTreeDelete($node);
+    }
+
+    /**
+     * BinaryTree insert of $value starting at $pointer
+     *
+     * @param RedBlackNode $pointer
+     * @param int $value
+     * @return RedBlackNode
+     */
+    private function binaryTreeInsert(RedBlackNode $pointer, int $value): RedBlackNode
+    {
+        $node = new RedBlackNode($value);
+        do {
+            if ($value < $pointer->getValue()) {
+                if ($pointer->getLeft() == null) {
+                    $pointer->setLeft($node);
+                    return $node;
+                }
+                $pointer = $pointer->getLeft();
+            } else {
+                if ($pointer->getRight() == null) {
+                    $pointer->setRight($node);
+                    return $node;
+                }
+                $pointer = $pointer->getRight();
+            }
+        } while (true);
+    }
+
+    /**
+     * BinaryTree deletion of $node
+     *
+     * @param RedBlackNode $node
+     * @return void
+     */
+    private function binaryTreeDelete(RedBlackNode $node): void
+    {
+        if ($node === $this->root) {
+            $this->root = null;
+            return;
+        }
+        $parentChildDirection = $node->isChild(Direction::Left)
+            ? Direction::Left
+            : Direction::Right;
+        if (!$node->getRight() && !$node->getLeft()) {
+            $node->getParent()->{$parentChildDirection->operation('set')}(null);
+        }
+        if ($node->getLeft() && $node->getRight()) {
+            $pointer = $node->getRight();
+            while ($pointer->getLeft()) {
+                $pointer = $pointer->getLeft();
+            }
+            if ($pointer->getParent()->isChild(Direction::Left)) {
+                $pointer->getParent()->setLeft($pointer->getRight());
+            } else {
+                $pointer->getParent()->setRight($pointer->getRight());
+            }
+            $node->getParent()->{$parentChildDirection->operation('set')}($pointer);
+            $pointer->setRight($node->getRight());
+        }
+        if ($node->getLeft() && !$node->getRight()) {
+            $node->getParent()->{$parentChildDirection->operation('set')}($node->getLeft());
+        }
+        if ($node->getRight() && !$node->getLeft()) {
+            $node->getParent()->{$parentChildDirection->operation('set')}($node->getRight());
+        }
+    }
+}