平衡二叉树插入节点

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));

}

// （向）右旋转操作，参数y为失衡节点
TreeNode rightRotate(TreeNode y) {

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

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

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

return x;

}

// （向）左旋转操作，参数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 insertNode(TreeNode root, int value) {

// 1. 执行标准BST插入，多层迭代
if (root == nullptr) return new TreeNode(value);

if (value < root->data) {
    root->left = insertNode(root->left, value);
} else if (value > root->data) {
    root->right = insertNode(root->right, value);
} else {
    return root; // 节点已存在，无需插入
}

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

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

// 4. 如果树不平衡，则根据情况进行旋转
// 左子树的左侧插入导致不平衡（LL情况）
if (balance > 1 && value < root->left->data) {
    return rightRotate(root);
}
// 右子树的右侧插入导致不平衡（RR情况）
if (balance < -1 && value > root->right->data) {
    return leftRotate(root);
}
// 左子树的右侧插入导致不平衡（LR情况）
if (balance > 1 && value > root->left->data) {
    root->left = leftRotate(root->left);
    return rightRotate(root);
}
// 右子树的左侧插入导致不平衡（RL情况）
if (balance < -1 && value < root->right->data) {
    root->right = rightRotate(root->right);
    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: ";
inorderTraversal(root);
std::cout << std::endl;

return 0;

}

示例：
旋转前

      y                                x
     / \                             /   \
    x   T3                          z     y
   / \         右旋转(y)            / \   / \
  z   T2    ------------->        T1  T2 T3  T4
 / \
T1  T4

旋转后

       x
     /   \
    z     y
   / \   / \
  T1 T2 T3 T4