AVL 树 , Splay 树 , 摊还分析

Node *rightRotate(AVLTree p) {
    AVLTreenew_p = p->left;
    p->left = new_p->right;
    new_p->right = p;
    p->height = MAX(HEIGHT(p->left), HEIGHT(p->right)) + 1;
    new_p->height = MAX(HEIGHT(new_p->left), HEIGHT(new_p->right)) + 1;
    return new_p;
}

Node *leftRotate(AVLTree p) {
    AVLTreenew_p = p->right;
    p->right = new_p->left;
    new_p->left = p;
    p->height = MAX(HEIGHT(p->left), HEIGHT(p->right)) + 1;
    new_p->height = MAX(HEIGHT(new_p->left), HEIGHT(new_p->right)) + 1;
    return new_p;
}

Node *LL_Rotate(AVLTree p) {
    return rightRotate(p);
}

Node *RR_Rotate(AVLTree p) {
    return leftRotate(p);
}

Node *LR_Rotate(AVLTree p) {
    p->left = leftRotate(p->left);
    return rightRotate(p);
}

Node *RL_Rotate(AVLTree p) {
    p->right = rightRotate(p->right);
    return leftRotate(p);
}

Node *CreateNode(int val) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->val = val;
    p->left = p->right = NULL;
    p->height = 0;
    return p;
}

Node *Insert(AVLTree tree, int val) {
    if (tree == NULL) {
        tree = CreateNode(val);
    } else if (val < tree->val) {
        tree->left = Insert(tree->left, val);
        if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2) { // 因为只插入一个节点，所以失衡必然为 2
            if (val < tree->left->val) {
                tree = LL_Rotate(tree);
            } else {
                tree = LR_Rotate(tree);
            }
        }
    } else if (val > tree->val) {
        tree->right = Insert(tree->right, val);
        if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2) { // 因为只插入一个节点，所以失衡必然为 2
            if (val > tree->right->val) {
                tree = RR_Rotate(tree);
            } else {
                tree = RL_Rotate(tree);
            }
        }
    } else {
        return NULL; // 重复的节点
    }
    tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;
    return tree;
}

void leftRotate(SplayTree p) {
    SplayTree x = p->right;
    // 将 x 的左儿子设为 p 的右儿子，更新 x 的父节点
    if(x) {
        p->right = x->left;
        if(x->left) x->left->parent = p;
        x->parent = p->parent;
    }

    if(p->parent) {
        if(p == p->parent->left) {
            p->parent->left = x;
        } else {
            p->parent->right = x;
        }
    } 
    if(x) x->left = p;
    p->parent = x;
}

void rightRotate(SplayTree p) {
    SplayTree x = p->left;
    // 将 x 的右儿子设为 p 的左儿子，更新 x 的父节点
    if(x) {
        p->left = x->right;
        if(x->right) x->right->parent = p;
        x->parent = p->parent;
    }
    if(p->parent) {
        if(p == p->parent->left) {
            p->parent->left = x;
        } else {
            p->parent->right = x;
        }
    }
    if(x) x->right = p;
    p->parent = x;
}

SplayTree CreateNode(int val) {
    SplayTree p = (Node *)malloc(sizeof(Node));
    p->val = val;
    p->left = p->right = p->parent = NULL;
    return p;
}

SplayTree Insert(SplayTree tree, int val) {
    if (tree == NULL) {
        tree = CreateNode(val);
    } else {
        SplayTree p = tree;
        SplayTree pre = NULL;
        while(p) {
            pre = p;
            if(val < p->val) {
                p = p->left;
            } else if(val > p->val) {
                p = p->right;
            } else {
                return NULL; // 重复的节点
            }
        }

        p = CreateNode(val);
        p->parent = pre;
        if(val < pre->val) {
            pre->left = p;
        } else {
            pre->right = p;
        }
        splay(p);
        tree = p;
    }
    return tree;
}

SplayTree Search(SplayTree tree, int val) {
    SplayTree p = tree;
    while(p) {
        if(val < p->val) {
            p = p->left;
        } else if(val > p->val) {
            p = p->right;
        } else {
            splay(p);
            return p;
        }
    }
    return NULL;
}

SplayTree Delete(SplayTree tree, int val) {
    SplayTree p = Search(tree, val);
    if(p == NULL) return tree;
    if(p->left == NULL) {
        tree = p->right;
        if(tree) tree->parent = NULL;
    } else {
        SplayTree x = p->left;
        // Find the maximum node in the left subtree
        while(x->right) x = x->right;
        splay(x);
        x->right = p->right;
        if(p->right) p->right->parent = x;
        tree = x;
    }
    free(p);
    return tree;
}