红黑树删除节点

include <iostream>

enum Color { RED, BLACK };

// 定义红黑树节点结构
struct TreeNode {

int data;
Color color;
TreeNode* parent;
TreeNode* left;
TreeNode* right;

TreeNode(int val) : data(val), color(RED), parent(nullptr), left(nullptr), right(nullptr) {}

};

// 左旋转操作
void leftRotate(TreeNode& root, TreeNode x) {

TreeNode* y = x->right;
x->right = y->left;
if (y->left != nullptr) {
    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->parent->right = y;
}
y->left = x;
x->parent = y;

}

// 右旋转操作
void rightRotate(TreeNode& root, TreeNode y) {

TreeNode* x = y->left;
y->left = x->right;
if (x->right != nullptr) {
    x->right->parent = y;
}
x->parent = y->parent;
if (y->parent == nullptr) {
    root = x;
} else if (y == y->parent->right) {
    y->parent->right = x;
} else {
    y->parent->left = x;
}
x->right = y;
y->parent = x;

}

// 获取节点的后继节点
TreeNode getSuccessor(TreeNode node) {

TreeNode* temp = node->right;
while (temp != nullptr && temp->left != nullptr) {
    temp = temp->left;
}
return temp;

}

// 删除节点修正红黑树性质
void deleteFixup(TreeNode& root, TreeNode x) {

while (x != root && x->color == BLACK) {
    if (x == x->parent->left) {
        TreeNode* w = x->parent->right;
        if (w->color == RED) {
            w->color = BLACK;
            x->parent->color = RED;
            leftRotate(root, x->parent);
            w = x->parent->right;
        }
        if (w->left->color == BLACK && w->right->color == BLACK) {
            w->color = RED;
            x = x->parent;
        } else {
            if (w->right->color == BLACK) {
                w->left->color = BLACK;
                w->color = RED;
                rightRotate(root, w);
                w = x->parent->right;
            }
            w->color = x->parent->color;
            x->parent->color = BLACK;
            w->right->color = BLACK;
            leftRotate(root, x->parent);
            x = root;
        }
    } else {
        TreeNode* w = x->parent->left;
        if (w->color == RED) {
            w->color = BLACK;
            x->parent->color = RED;
            rightRotate(root, x->parent);
            w = x->parent->left;
        }
        if (w->right->color == BLACK && w->left->color == BLACK) {
            w->color = RED;
            x = x->parent;
        } else {
            if (w->left->color == BLACK) {
                w->right->color = BLACK;
                w->color = RED;
                leftRotate(root, w);
                w = x->parent->left;
            }
            w->color = x->parent->color;
            x->parent->color = BLACK;
            w->left->color = BLACK;
            rightRotate(root, x->parent);
            x = root;
        }
    }
}
x->color = BLACK;

}

// 在红黑树中删除节点
void deleteNode(TreeNode& root, TreeNode z) {

TreeNode* y = z;
TreeNode* x = nullptr;
Color original_color = y->color;

if (z->left == nullptr) {
    x = z->right;
    transplant(root, z, z->right);
} else if (z->right == nullptr) {
    x = z->left;
    transplant(root, z, z->left);
} else {
    y = getSuccessor(z);
    original_color = y->color;
    x = y->right;
    if (y->parent == z) {
        x->parent = y;
    } else {
        transplant(root, y, y->right);
        y->right = z->right;
        y->right->parent = y;
    }
    transplant(root, z, y);
    y->left = z->left;
    y->left->parent = y;
    y->color = z->color;
}

if (original_color == BLACK) {
    deleteFixup(root, x);
}
delete z;

}

// 替换节点
void transplant(TreeNode& root, TreeNode u, TreeNode* v) {

if (u->parent == nullptr) {
    root = v;
} else if (u == u->parent->left) {
    u->parent->left = v;
} else {
    u->parent->right = v;
}
if (v != nullptr) {
    v->parent = u->parent;
}

}

// 中序遍历打印红黑树节点值
void inorderTraversal(TreeNode* root) {

if (root == nullptr) return;
inorderTraversal(root->left);
std::cout << root->data << " ";
inorderTraversal(root->right);

}

int main() {

TreeNode* root = nullptr;

// 添加节点
insertNode(root, new TreeNode(10));
insertNode(root, new TreeNode(20));
insertNode(root, new TreeNode(30));
insertNode(root, new TreeNode(40));
insertNode(root, new TreeNode(50));
insertNode(root, new TreeNode(25));

std::cout << "Inorder Traversal before deletion: ";
inorderTraversal(root);
std::cout << std::endl;

// 删除节点值为30的节点
TreeNode* node_to_delete = root->right;
deleteNode(root, node_to_delete);

std::cout << "Inorder Traversal after deletion: ";
inorderTraversal(root);
std::cout << std::endl;

return 0;

}