平衡二叉树删除节点

include <iostream>

include <algorithm>

// 定义平衡二叉树节点结构
struct TreeNode {

int data;
TreeNode* left;
TreeNode* right;
int height;

TreeNode(int val) : data(val), left(nullptr), right(nullptr), height(1) {}

};

// 计算节点的高度
int getHeight(TreeNode* node) {

if (node == nullptr) return 0;
return node->height;

}

// 获取节点的平衡因子
int getBalanceFactor(TreeNode* node) {

if (node == nullptr) return 0;
return getHeight(node->left) - getHeight(node->right);

}

// 更新节点的高度
void updateHeight(TreeNode* node) {

node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));

}

// 右旋转操作
TreeNode rightRotate(TreeNode y) {

TreeNode* x = y->left;
TreeNode* T2 = x->right;

// 执行旋转
x->right = y;
y->left = T2;

// 更新高度
updateHeight(y);
updateHeight(x);

return x;

}

// 左旋转操作
TreeNode leftRotate(TreeNode x) {

TreeNode* y = x->right;
TreeNode* T2 = y->left;

// 执行旋转
y->left = x;
x->right = T2;

// 更新高度
updateHeight(x);
updateHeight(y);

return y;

}

// 在平衡二叉树中查找要删除的节点
TreeNode deleteNode(TreeNode root, int key) {

if (root == nullptr) return root;

// 执行标准BST删除
if (key < root->data) {
    root->left = deleteNode(root->left, key);
} else if (key > root->data) {
    root->right = deleteNode(root->right, key);
} else {
    // 节点有一个或没有子节点
    if (root->left == nullptr || root->right == nullptr) {
        TreeNode* temp = root->left ? root->left : root->right;

        // 没有子节点的情况
        if (temp == nullptr) {
            temp = root;
            root = nullptr;
        } else { // 有一个子节点的情况
            *root = *temp; // 将子节点的内容复制到要删除的节点
        }

        delete temp;
    } else { // 节点有两个子节点
        TreeNode* temp = root->right;
        while (temp->left != nullptr) {
            temp = temp->left;
        }
        root->data = temp->data;
        root->right = deleteNode(root->right, temp->data);
    }
}

if (root == nullptr) return root;

// 更新节点的高度
updateHeight(root);

// 获取当前节点的平衡因子
int balance = getBalanceFactor(root);

// 如果树不平衡，则根据情况进行旋转
// 左子树的不平衡情况
if (balance > 1) {
    // LR情况
    if (getBalanceFactor(root->left) < 0) {
        root->left = leftRotate(root->left);
        return rightRotate(root);
    }
    // LL情况
    return rightRotate(root);
}
// 右子树的不平衡情况
if (balance < -1) {
    // RL情况
    if (getBalanceFactor(root->right) > 0) {
        root->right = rightRotate(root->right);
        return leftRotate(root);
    }
    // RR情况
    return leftRotate(root);
}

return root;

}

// 中序遍历打印平衡二叉树节点值
void inorderTraversal(TreeNode* root) {

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

}

int main() {

TreeNode* root = nullptr;

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

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

// 删除节点值为30的节点
root = deleteNode(root, 30);

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

return 0;

}