AVL Tree Implementation - Problem

An AVL tree is a self-balancing binary search tree where the heights of the two child subtrees of any node differ by at most one. If at any time they differ by more than one, rebalancing is done to restore this property.

Implement an AVL tree class with the following operations:

insert(value) - Insert a value and rebalance if necessary
delete(value) - Delete a value and rebalance if necessary
search(value) - Search for a value, return true if found
getInorder() - Return inorder traversal as an array

For this problem, you need to implement a function that processes a sequence of operations and returns the final inorder traversal of the tree.

Input & Output

Example 1 — Basic AVL Operations

$ Input: operations = [["insert", 10], ["insert", 20], ["insert", 30]]

› Output: [10, 20, 30]

💡 Note: Insert 10 (root), 20 (right child), 30 (causes imbalance). AVL performs left rotation: 20 becomes root with 10 left and 30 right. Inorder: [10, 20, 30].

Example 2 — Insert and Delete

$ Input: operations = [["insert", 10], ["insert", 5], ["insert", 15], ["delete", 10]]

› Output: [5, 15]

💡 Note: Build tree with 10 as root, 5 left, 15 right. Delete 10: replace with inorder successor 15, leaving 5 as new root and 15 as right child.

Example 3 — Complex Rotations

$ Input: operations = [["insert", 10], ["insert", 5], ["insert", 15], ["insert", 2], ["insert", 7]]

› Output: [2, 5, 7, 10, 15]

💡 Note: Multiple insertions creating a balanced AVL tree through automatic rotations. Final inorder traversal gives sorted sequence.

Constraints

1 ≤ operations.length ≤ 100
operations[i][0] ∈ {"insert", "delete", "search"}
1 ≤ operations[i][1] ≤ 1000
All values in operations are unique for insert/delete

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Meta 18

The key insight is using automatic rotations to maintain tree balance after every insertion and deletion. AVL trees guarantee O(log n) height through balance factor monitoring and four rotation types (LL, RR, LR, RL). Best approach uses height tracking with immediate rebalancing. Time: O(log n), Space: O(log n)

Common Approaches

✓ AVL Tree with Height Tracking

⏱️ Time: O(log n) Space: O(log n)

Track node heights and calculate balance factors to determine when rotations are needed. Perform single or double rotations to maintain AVL property after each insertion and deletion.

Simple BST Without Balancing

⏱️ Time: O(n) Space: O(n)

Insert and delete nodes like a regular BST, allowing the tree to become unbalanced. This can degrade to a linear structure in worst case, making operations slow.

AVL Tree with Height Tracking — Algorithm Steps

Calculate height and balance factor for each node
Check if balance factor exceeds ±1 after operations
Perform appropriate rotation (LL, RR, LR, RL) to rebalance
Update heights after rotations

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert 10, 20

Tree is balanced (balance factor ≤ 1)

Insert 30

Right-heavy, balance factor = -2

Left Rotation

Rotate to restore balance, all operations stay O(log n)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct AVLNode {
    int val, height;
    struct AVLNode* left;
    struct AVLNode* right;
};

struct AVLNode* createNode(int val) {
    struct AVLNode* node = malloc(sizeof(struct AVLNode));
    node->val = val;
    node->height = 1;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int getHeight(struct AVLNode* node) {
    return node ? node->height : 0;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int getBalance(struct AVLNode* node) {
    return node ? getHeight(node->left) - getHeight(node->right) : 0;
}

void updateHeight(struct AVLNode* node) {
    if (node) {
        node->height = 1 + max(getHeight(node->left), getHeight(node->right));
    }
}

struct AVLNode* rightRotate(struct AVLNode* y) {
    struct AVLNode* x = y->left;
    struct AVLNode* T2 = x->right;
    x->right = y;
    y->left = T2;
    updateHeight(y);
    updateHeight(x);
    return x;
}

struct AVLNode* leftRotate(struct AVLNode* x) {
    struct AVLNode* y = x->right;
    struct AVLNode* T2 = y->left;
    y->left = x;
    x->right = T2;
    updateHeight(x);
    updateHeight(y);
    return y;
}

struct AVLNode* insert(struct AVLNode* node, int val) {
    if (!node) return createNode(val);
    
    if (val < node->val) {
        node->left = insert(node->left, val);
    } else if (val > node->val) {
        node->right = insert(node->right, val);
    } else {
        return node;
    }
    
    updateHeight(node);
    int balance = getBalance(node);
    
    if (balance > 1 && val < node->left->val) {
        return rightRotate(node);
    }
    
    if (balance < -1 && val > node->right->val) {
        return leftRotate(node);
    }
    
    if (balance > 1 && val > node->left->val) {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }
    
    if (balance < -1 && val < node->right->val) {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }
    
    return node;
}

struct AVLNode* delete(struct AVLNode* node, int val) {
    if (!node) return NULL;
    
    if (val < node->val) {
        node->left = delete(node->left, val);
    } else if (val > node->val) {
        node->right = delete(node->right, val);
    } else {
        if (!node->left) return node->right;
        if (!node->right) return node->left;
        
        struct AVLNode* temp = node->right;
        while (temp->left) temp = temp->left;
        node->val = temp->val;
        node->right = delete(node->right, temp->val);
    }
    
    updateHeight(node);
    int balance = getBalance(node);
    
    if (balance > 1 && getBalance(node->left) >= 0) {
        return rightRotate(node);
    }
    
    if (balance > 1 && getBalance(node->left) < 0) {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }
    
    if (balance < -1 && getBalance(node->right) <= 0) {
        return leftRotate(node);
    }
    
    if (balance < -1 && getBalance(node->right) > 0) {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }
    
    return node;
}

void inorder(struct AVLNode* node, int* result, int* index) {
    if (node) {
        inorder(node->left, result, index);
        result[(*index)++] = node->val;
        inorder(node->right, result, index);
    }
}

int main() {
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Height is always O(log n) due to balancing, each operation traverses at most log n nodes

⚡ Linearithmic

Space Complexity

O(log n)

O(n) space for nodes plus O(log n) recursion stack depth

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

AVL Tree Implementation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

AVL Tree with Height Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler