AVL Tree | Set 1 (Insertion) - GeeksforGeeks

19 Feb, 2022
AVL tree is a self-balancing Binary Search Tree (BST) where the difference between heights of left and right subtrees cannot be more than one for all nodes. An Example Tree that is an AVL Tree  
The above tree is AVL because differences between heights of left and right subtrees for every node is less than or equal to 1.An Example Tree that is NOT an AVL Tree 
The above tree is not AVL because differences between heights of left and right subtrees for 8 and 12 is greater than 1.Why AVL Trees? Most of the BST operations (e.g., search, max, min, insert, delete.. etc) take O(h) time where h is the height of the BST. The cost of these operations may become O(n) for a skewed Binary tree. If we make sure that height of the tree remains O(Logn) after every insertion and deletion, then we can guarantee an upper bound of O(Logn) for all these operations. The height of an AVL tree is always O(Logn) where n is the number of nodes in the tree (See this video lecture for proof). 
Insertion To make sure that the given tree remains AVL after every insertion, we must augment the standard BST insert operation to perform some re-balancing. Following are two basic operations that can be performed to re-balance a BST without violating the BST property (keys(left) < key(root) < keys(right)). 1) Left Rotation 2) Right Rotation
T1, T2 and T3 are subtrees of the tree 
rooted with y (on the left side) or x (on 
the right side)           
     y                               x
    / \     Right Rotation          /  \
   x   T3   - - - - - - - >        T1   y 
  / \       < - - - - - - -            / \
 T1  T2     Left Rotation            T2  T3
Keys in both of the above trees follow the 
following order 
 keys(T1) < key(x) < keys(T2) < key(y) < keys(T3)
So BST property is not violated anywhere.
Steps to follow for insertion Let the newly inserted node be w 1) Perform standard BST insert for w. 2) Starting from w, travel up and find the first unbalanced node. Let z be the first unbalanced node, y be the child of z that comes on the path from w to z and x be the grandchild of z that comes on the path from w to z. 3) Re-balance the tree by performing appropriate rotations on the subtree rooted with z. There can be 4 possible cases that needs to be handled as x, y and z can be arranged in 4 ways. Following are the possible 4 arrangements: a) y is left child of z and x is left child of y (Left Left Case) b) y is left child of z and x is right child of y (Left Right Case) c) y is right child of z and x is right child of y (Right Right Case) d) y is right child of z and x is left child of y (Right Left Case)Following are the operations to be performed in above mentioned 4 cases. In all of the cases, we only need to re-balance the subtree rooted with z and the complete tree becomes balanced as the height of subtree (After appropriate rotations) rooted with z becomes same as it was before insertion. (See this video lecture for proof)a) Left Left Case 
T1, T2, T3 and T4 are subtrees.
         z                                      y 
        / \                                   /   \
       y   T4      Right Rotate (z)          x      z
      / \          - - - - - - - - ->      /  \    /  \ 
     x   T3                               T1  T2  T3  T4
    / \
  T1   T2
b) Left Right Case 
     z                               z                           x
    / \                            /   \                        /  \ 
   y   T4  Left Rotate (y)        x    T4  Right Rotate(z)    y      z
  / \      - - - - - - - - ->    /  \      - - - - - - - ->  / \    / \
T1   x                          y    T3                    T1  T2 T3  T4
    / \                        / \
  T2   T3                    T1   T2
c) Right Right Case 
  z                                y
 /  \                            /   \ 
T1   y     Left Rotate(z)       z      x
    /  \   - - - - - - - ->    / \    / \
   T2   x                     T1  T2 T3  T4
       / \
     T3  T4
d) Right Left Case 
   z                            z                            x
  / \                          / \                          /  \ 
T1   y   Right Rotate (y)    T1   x      Left Rotate(z)   z      y
    / \  - - - - - - - - ->     /  \   - - - - - - - ->  / \    / \
   x   T4                      T2   y                  T1  T2  T3  T4
  / \                              /  \
T2   T3                           T3   T4
Insertion Examples:  
 
 
 
 
Implementation Following is the implementation for AVL Tree Insertion. The following implementation uses the recursive BST insert to insert a new node. In the recursive BST insert, after insertion, we get pointers to all ancestors one by one in a bottom-up manner. So we don’t need parent pointer to travel up. The recursive code itself travels up and visits all the ancestors of the newly inserted node. 1) Perform the normal BST insertion. 2) The current node must be one of the ancestors of the newly inserted node. Update the height of the current node. 3) Get the balance factor (left subtree height – right subtree height) of the current node. 4) If balance factor is greater than 1, then the current node is unbalanced and we are either in Left Left case or left Right case. To check whether it is left left case or not, compare the newly inserted key with the key in left subtree root. 5) If balance factor is less than -1, then the current node is unbalanced and we are either in Right Right case or Right-Left case. To check whether it is Right Right case or not, compare the newly inserted key with the key in right subtree root. 
C++
C
Java
Python3
C#
Javascript
// C++ program to insert a node in AVL tree#include<bits/stdc++.h>using namespace std; // An AVL tree nodeclass Node{    public:    int key;    Node *left;    Node *right;    int height;}; // A utility function to get maximum// of two integersint max(int a, int b); // A utility function to get the// height of the treeint height(Node *N){    if (N == NULL)        return 0;    return N->height;} // A utility function to get maximum// of two integersint max(int a, int b){    return (a > b)? a : b;} /* Helper function that allocates a   new node with the given key and   NULL left and right pointers. */Node* newNode(int key){    Node* node = new Node();    node->key = key;    node->left = NULL;    node->right = NULL;    node->height = 1; // new node is initially                      // added at leaf    return(node);} // A utility function to right// rotate subtree rooted with y// See the diagram given above.Node *rightRotate(Node *y){    Node *x = y->left;    Node *T2 = x->right;     // Perform rotation    x->right = y;    y->left = T2;     // Update heights    y->height = max(height(y->left),                    height(y->right)) + 1;    x->height = max(height(x->left),                    height(x->right)) + 1;     // Return new root    return x;} // A utility function to left// rotate subtree rooted with x// See the diagram given above.Node *leftRotate(Node *x){    Node *y = x->right;    Node *T2 = y->left;     // Perform rotation    y->left = x;    x->right = T2;     // Update heights    x->height = max(height(x->left),                       height(x->right)) + 1;    y->height = max(height(y->left),                    height(y->right)) + 1;     // Return new root    return y;} // Get Balance factor of node Nint getBalance(Node *N){    if (N == NULL)        return 0;    return height(N->left) - height(N->right);} // Recursive function to insert a key// in the subtree rooted with node and// returns the new root of the subtree.Node* insert(Node* node, int key){    /* 1. Perform the normal BST insertion */    if (node == NULL)        return(newNode(key));     if (key < node->key)        node->left = insert(node->left, key);    else if (key > node->key)        node->right = insert(node->right, key);    else // Equal keys are not allowed in BST        return node;     /* 2. Update height of this ancestor node */    node->height = 1 + max(height(node->left),                        height(node->right));     /* 3. Get the balance factor of this ancestor        node to check whether this node became        unbalanced */    int balance = getBalance(node);     // If this node becomes unbalanced, then    // there are 4 cases     // Left Left Case    if (balance > 1 && key < node->left->key)        return rightRotate(node);     // Right Right Case    if (balance < -1 && key > node->right->key)        return leftRotate(node);     // Left Right Case    if (balance > 1 && key > node->left->key)    {        node->left = leftRotate(node->left);        return rightRotate(node);    }     // Right Left Case    if (balance < -1 && key < node->right->key)    {        node->right = rightRotate(node->right);        return leftRotate(node);    }     /* return the (unchanged) node pointer */    return node;} // A utility function to print preorder// traversal of the tree.// The function also prints height// of every nodevoid preOrder(Node *root){    if(root != NULL)    {        cout << root->key << " ";        preOrder(root->left);        preOrder(root->right);    }} // Driver Codeint main(){    Node *root = NULL;         /* Constructing tree given in    the above figure */    root = insert(root, 10);    root = insert(root, 20);    root = insert(root, 30);    root = insert(root, 40);    root = insert(root, 50);    root = insert(root, 25);         /* The constructed AVL Tree would be                30            / \            20 40            / \ \        10 25 50    */    cout << "Preorder traversal of the "            "constructed AVL tree is \n";    preOrder(root);         return 0;} // This code is contributed by// rathbhupendra
// C program to insert a node in AVL tree#include<stdio.h>#include<stdlib.h> // An AVL tree nodestruct Node{    int key;    struct Node *left;    struct Node *right;    int height;}; // A utility function to get maximum of two integersint max(int a, int b); // A utility function to get the height of the treeint height(struct Node *N){    if (N == NULL)        return 0;    return 1+max(height(N->left), height(N->right));} // A utility function to get maximum of two integersint max(int a, int b){    return (a > b)? a : b;} /* Helper function that allocates a new node with the given key and    NULL left and right pointers. */struct Node* newNode(int key){    struct Node* node = (struct Node*)                        malloc(sizeof(struct Node));    node->key   = key;    node->left   = NULL;    node->right  = NULL;    node->height = 0;  // new node is initially added at leaf    return(node);} // A utility function to right rotate subtree rooted with y// See the diagram given above.struct Node *rightRotate(struct Node *y){    struct Node *x = y->left;    struct Node *T2 = x->right;     // Perform rotation    x->right = y;    y->left = T2;     // Update heights    y->height = height(y);    x->height = height(x);     // Return new root    return x;} // A utility function to left rotate subtree rooted with x// See the diagram given above.struct Node *leftRotate(struct Node *x){    struct Node *y = x->right;    struct Node *T2 = y->left;     // Perform rotation    y->left = x;    x->right = T2;     //  Update heights    x->height = height(x);    y->height = height(y);     // Return new root    return y;} // Get Balance factor of node Nint getBalance(struct Node *N){    if (N == NULL)        return 0;    return height(N->left) - height(N->right);} // Recursive function to insert a key in the subtree rooted// with node and returns the new root of the subtree.struct Node* insert(struct Node* node, int key){    /* 1.  Perform the normal BST insertion */    if (node == NULL)        return(newNode(key));     if (key < node->key)        node->left  = insert(node->left, key);    else if (key > node->key)        node->right = insert(node->right, key);    else // Equal keys are not allowed in BST        return node;     /* 2. Update height of this ancestor node */    node->height = height(node);     /* 3. Get the balance factor of this ancestor          node to check whether this node became          unbalanced */    int balance = getBalance(node);     // If this node becomes unbalanced, then    // there are 4 cases     // Left Left Case    if (balance > 1 && key < node->left->key)        return rightRotate(node);     // Right Right Case    if (balance < -1 && key > node->right->key)        return leftRotate(node);     // Left Right Case    if (balance > 1 && key > node->left->key)    {        node->left =  leftRotate(node->left);        return rightRotate(node);    }     // Right Left Case    if (balance < -1 && key < node->right->key)    {        node->right = rightRotate(node->right);        return leftRotate(node);    }     /* return the (unchanged) node pointer */    return node;} // A utility function to print preorder traversal// of the tree.// The function also prints height of every nodevoid preOrder(struct Node *root){    if(root != NULL)    {        printf("%d ", root->key);        preOrder(root->left);        preOrder(root->right);    }} /* Driver program to test above function*/int main(){  struct Node *root = NULL;   /* Constructing tree given in the above figure */  root = insert(root, 10);  root = insert(root, 20);  root = insert(root, 30);  root = insert(root, 40);  root = insert(root, 50);  root = insert(root, 25);   /* The constructed AVL Tree would be            30           /  \         20   40        /  \     \       10  25    50  */   printf("Preorder traversal of the constructed AVL"         " tree is \n");  preOrder(root);   return 0;}
// Java program for insertion in AVL Treeclass Node {    int key, height;    Node left, right;     Node(int d) {        key = d;        height = 1;    }} class AVLTree {     Node root;     // A utility function to get the height of the tree    int height(Node N) {        if (N == null)            return 0;         return N.height;    }     // A utility function to get maximum of two integers    int max(int a, int b) {        return (a > b) ? a : b;    }     // A utility function to right rotate subtree rooted with y    // See the diagram given above.    Node rightRotate(Node y) {        Node x = y.left;        Node T2 = x.right;         // Perform rotation        x.right = y;        y.left = T2;         // Update heights        y.height = max(height(y.left), height(y.right)) + 1;        x.height = max(height(x.left), height(x.right)) + 1;         // Return new root        return x;    }     // A utility function to left rotate subtree rooted with x    // See the diagram given above.    Node leftRotate(Node x) {        Node y = x.right;        Node T2 = y.left;         // Perform rotation        y.left = x;        x.right = T2;         //  Update heights        x.height = max(height(x.left), height(x.right)) + 1;        y.height = max(height(y.left), height(y.right)) + 1;         // Return new root        return y;    }     // Get Balance factor of node N    int getBalance(Node N) {        if (N == null)            return 0;         return height(N.left) - height(N.right);    }     Node insert(Node node, int key) {         /* 1.  Perform the normal BST insertion */        if (node == null)            return (new Node(key));         if (key < node.key)            node.left = insert(node.left, key);        else if (key > node.key)            node.right = insert(node.right, key);        else // Duplicate keys not allowed            return node;         /* 2. Update height of this ancestor node */        node.height = 1 + max(height(node.left),                              height(node.right));         /* 3. Get the balance factor of this ancestor              node to check whether this node became              unbalanced */        int balance = getBalance(node);         // If this node becomes unbalanced, then there        // are 4 cases Left Left Case        if (balance > 1 && key < node.left.key)            return rightRotate(node);         // Right Right Case        if (balance < -1 && key > node.right.key)            return leftRotate(node);         // Left Right Case        if (balance > 1 && key > node.left.key) {            node.left = leftRotate(node.left);            return rightRotate(node);        }         // Right Left Case        if (balance < -1 && key < node.right.key) {            node.right = rightRotate(node.right);            return leftRotate(node);        }         /* return the (unchanged) node pointer */        return node;    }     // A utility function to print preorder traversal    // of the tree.    // The function also prints height of every node    void preOrder(Node node) {        if (node != null) {            System.out.print(node.key + " ");            preOrder(node.left);            preOrder(node.right);        }    }     public static void main(String[] args) {        AVLTree tree = new AVLTree();         /* Constructing tree given in the above figure */        tree.root = tree.insert(tree.root, 10);        tree.root = tree.insert(tree.root, 20);        tree.root = tree.insert(tree.root, 30);        tree.root = tree.insert(tree.root, 40);        tree.root = tree.insert(tree.root, 50);        tree.root = tree.insert(tree.root, 25);         /* The constructed AVL Tree would be             30            /  \          20   40         /  \     \        10  25    50        */        System.out.println("Preorder traversal" +                        " of constructed tree is : ");        tree.preOrder(tree.root);    }}// This code has been contributed by Mayank Jaiswal
# Python code to insert a node in AVL tree # Generic tree node classclass TreeNode(object):    def __init__(self, val):        self.val = val        self.left = None        self.right = None        self.height = 1 # AVL tree class which supports the# Insert operationclass AVL_Tree(object):     # Recursive function to insert key in    # subtree rooted with node and returns    # new root of subtree.    def insert(self, root, key):             # Step 1 - Perform normal BST        if not root:            return TreeNode(key)        elif key < root.val:            root.left = self.insert(root.left, key)        else:            root.right = self.insert(root.right, key)         # Step 2 - Update the height of the        # ancestor node        root.height = 1 + max(self.getHeight(root.left),                           self.getHeight(root.right))         # Step 3 - Get the balance factor        balance = self.getBalance(root)         # Step 4 - If the node is unbalanced,        # then try out the 4 cases        # Case 1 - Left Left        if balance > 1 and key < root.left.val:            return self.rightRotate(root)         # Case 2 - Right Right        if balance < -1 and key > root.right.val:            return self.leftRotate(root)         # Case 3 - Left Right        if balance > 1 and key > root.left.val:            root.left = self.leftRotate(root.left)            return self.rightRotate(root)         # Case 4 - Right Left        if balance < -1 and key < root.right.val:            root.right = self.rightRotate(root.right)            return self.leftRotate(root)         return root     def leftRotate(self, z):         y = z.right        T2 = y.left         # Perform rotation        y.left = z        z.right = T2         # Update heights        z.height = 1 + max(self.getHeight(z.left),                         self.getHeight(z.right))        y.height = 1 + max(self.getHeight(y.left),                         self.getHeight(y.right))         # Return the new root        return y     def rightRotate(self, z):         y = z.left        T3 = y.right         # Perform rotation        y.right = z        z.left = T3         # Update heights        z.height = 1 + max(self.getHeight(z.left),                        self.getHeight(z.right))        y.height = 1 + max(self.getHeight(y.left),                        self.getHeight(y.right))         # Return the new root        return y     def getHeight(self, root):        if not root:            return 0         return root.height     def getBalance(self, root):        if not root:            return 0         return self.getHeight(root.left) - self.getHeight(root.right)     def preOrder(self, root):         if not root:            return         print("{0} ".format(root.val), end="")        self.preOrder(root.left)        self.preOrder(root.right)  # Driver program to test above functionmyTree = AVL_Tree()root = None root = myTree.insert(root, 10)root = myTree.insert(root, 20)root = myTree.insert(root, 30)root = myTree.insert(root, 40)root = myTree.insert(root, 50)root = myTree.insert(root, 25) """The constructed AVL Tree would be            30           /  \         20   40        /  \     \       10  25    50""" # Preorder Traversalprint("Preorder traversal of the",      "constructed AVL tree is")myTree.preOrder(root)print() # This code is contributed by Ajitesh Pathak
// C# program for insertion in AVL Treeusing System; class Node{    public int key, height;    public Node left, right;     public Node(int d)    {        key = d;        height = 1;    }} public class AVLTree{     Node root;     // A utility function to get    // the height of the tree    int height(Node N)    {        if (N == null)            return 0;         return N.height;    }     // A utility function to get    // maximum of two integers    int max(int a, int b)    {        return (a > b) ? a : b;    }     // A utility function to right    // rotate subtree rooted with y    // See the diagram given above.    Node rightRotate(Node y)    {        Node x = y.left;        Node T2 = x.right;         // Perform rotation        x.right = y;        y.left = T2;         // Update heights        y.height = max(height(y.left),                    height(y.right)) + 1;        x.height = max(height(x.left),                    height(x.right)) + 1;         // Return new root        return x;    }     // A utility function to left    // rotate subtree rooted with x    // See the diagram given above.    Node leftRotate(Node x)    {        Node y = x.right;        Node T2 = y.left;         // Perform rotation        y.left = x;        x.right = T2;         // Update heights        x.height = max(height(x.left),                    height(x.right)) + 1;        y.height = max(height(y.left),                    height(y.right)) + 1;         // Return new root        return y;    }     // Get Balance factor of node N    int getBalance(Node N)    {        if (N == null)            return 0;         return height(N.left) - height(N.right);    }     Node insert(Node node, int key)    {         /* 1. Perform the normal BST insertion */        if (node == null)            return (new Node(key));         if (key < node.key)            node.left = insert(node.left, key);        else if (key > node.key)            node.right = insert(node.right, key);        else // Duplicate keys not allowed            return node;         /* 2. Update height of this ancestor node */        node.height = 1 + max(height(node.left),                            height(node.right));         /* 3. Get the balance factor of this ancestor            node to check whether this node became            unbalanced */        int balance = getBalance(node);         // If this node becomes unbalanced, then there        // are 4 cases Left Left Case        if (balance > 1 && key < node.left.key)            return rightRotate(node);         // Right Right Case        if (balance < -1 && key > node.right.key)            return leftRotate(node);         // Left Right Case        if (balance > 1 && key > node.left.key)        {            node.left = leftRotate(node.left);            return rightRotate(node);        }         // Right Left Case        if (balance < -1 && key < node.right.key)        {            node.right = rightRotate(node.right);            return leftRotate(node);        }         /* return the (unchanged) node pointer */        return node;    }     // A utility function to print preorder traversal    // of the tree.    // The function also prints height of every node    void preOrder(Node node)    {        if (node != null)        {            Console.Write(node.key + " ");            preOrder(node.left);            preOrder(node.right);        }    }     // Driver code    public static void Main(String[] args)    {        AVLTree tree = new AVLTree();         /* Constructing tree given in the above figure */        tree.root = tree.insert(tree.root, 10);        tree.root = tree.insert(tree.root, 20);        tree.root = tree.insert(tree.root, 30);        tree.root = tree.insert(tree.root, 40);        tree.root = tree.insert(tree.root, 50);        tree.root = tree.insert(tree.root, 25);         /* The constructed AVL Tree would be            30            / \        20 40        / \ \        10 25 50        */        Console.Write("Preorder traversal" +                        " of constructed tree is : ");        tree.preOrder(tree.root);    }} // This code has been contributed// by PrinciRaj1992
<script>       // JavaScript program for insertion in AVL Tree      class Node {        constructor(d) {          this.key = d;          this.height = 1;          this.left = null;          this.right = null;        }      }       class AVLTree {        constructor() {          this.root = null;        }         // A utility function to get        // the height of the tree        height(N) {          if (N == null) return 0;           return N.height;        }         // A utility function to get        // maximum of two integers        max(a, b) {          return a > b ? a : b;        }         // A utility function to right        // rotate subtree rooted with y        // See the diagram given above.        rightRotate(y) {          var x = y.left;          var T2 = x.right;           // Perform rotation          x.right = y;          y.left = T2;           // Update heights          y.height = this.max(this.height(y.left),          this.height(y.right)) + 1;          x.height = this.max(this.height(x.left),          this.height(x.right)) + 1;           // Return new root          return x;        }         // A utility function to left        // rotate subtree rooted with x        // See the diagram given above.        leftRotate(x) {          var y = x.right;          var T2 = y.left;           // Perform rotation          y.left = x;          x.right = T2;           // Update heights          x.height = this.max(this.height(x.left),          this.height(x.right)) + 1;          y.height = this.max(this.height(y.left),          this.height(y.right)) + 1;           // Return new root          return y;        }         // Get Balance factor of node N        getBalance(N) {          if (N == null) return 0;           return this.height(N.left) - this.height(N.right);        }         insert(node, key) {          /* 1. Perform the normal BST insertion */          if (node == null) return new Node(key);           if (key < node.key)          node.left = this.insert(node.left, key);          else if (key > node.key)          node.right = this.insert(node.right, key);          // Duplicate keys not allowed          else return node;           /* 2. Update height of this ancestor node */          node.height =            1 + this.max(this.height(node.left),                this.height(node.right));           /* 3. Get the balance factor of this ancestor            node to check whether this node became            unbalanced */          var balance = this.getBalance(node);           // If this node becomes unbalanced, then there          // are 4 cases Left Left Case          if (balance > 1 && key < node.left.key)          return this.rightRotate(node);           // Right Right Case          if (balance < -1 && key > node.right.key)            return this.leftRotate(node);           // Left Right Case          if (balance > 1 && key > node.left.key) {            node.left = this.leftRotate(node.left);            return this.rightRotate(node);          }           // Right Left Case          if (balance < -1 && key < node.right.key) {            node.right = this.rightRotate(node.right);            return this.leftRotate(node);          }           /* return the (unchanged) node pointer */          return node;        }         // A utility function to print preorder traversal        // of the tree.        // The function also prints height of every node        preOrder(node) {          if (node != null) {            document.write(node.key + " ");            this.preOrder(node.left);            this.preOrder(node.right);          }        }      }      // Driver code      var tree = new AVLTree();       /* Constructing tree given in the above figure */      tree.root = tree.insert(tree.root, 10);      tree.root = tree.insert(tree.root, 20);      tree.root = tree.insert(tree.root, 30);      tree.root = tree.insert(tree.root, 40);      tree.root = tree.insert(tree.root, 50);      tree.root = tree.insert(tree.root, 25);       /* The constructed AVL Tree would be            30            / \           20 40          / \   \         10 25  50        */      document.write(      "Preorder traversal of the " + "constructed AVL tree is <br>"      );      tree.preOrder(tree.root);       </script>
Output: 
  Preorder traversal of the constructed AVL tree is
  30 20 10 25 40 50
Time Complexity: The rotation operations (left and right rotate) take constant time as only a few pointers are being changed there. Updating the height and getting the balance factor also takes constant time. So the time complexity of AVL insert remains same as BST insert which is O(h) where h is the height of the tree. Since AVL tree is balanced, the height is O(Logn). So time complexity of AVL insert is O(Logn).Comparison with Red Black Tree The AVL tree and other self-balancing search trees like Red Black are useful to get all basic operations done in O(log n) time. The AVL trees are more balanced compared to Red-Black Trees, but they may cause more rotations during insertion and deletion. So if your application involves many frequent insertions and deletions, then Red Black trees should be preferred. And if the insertions and deletions are less frequent and search is the more frequent operation, then AVL tree should be preferred over Red Black Tree.Following is the post for delete. AVL Tree | Set 2 (Deletion)Following are some posts that have used self-balancing search trees.Median in a stream of integers (running integers) Maximum of all subarrays of size k Count smaller elements on right side
References: IITD Video Lecture on AVL Tree Introduction IITD Video Lecture on AVL Tree Insertion and DeletionPlease write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
princiraj1992
rathbhupendra
Akanksha_Rai
sohamshinde04
nocturnalstoryteller
rdtank
kaiwenzheng644
Amazon
AVL-Tree
Citicorp
Informatica
MakeMyTrip
Morgan Stanley
Oracle
Oxigen Wallet
Self-Balancing-BST
Snapdeal
Advanced Data Structure
Binary Search Tree
Tree
Morgan Stanley
Amazon
Snapdeal
MakeMyTrip
Oracle
Oxigen Wallet
Informatica
Citicorp
Binary Search Tree
Tree
AVL-Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Agents in Artificial Intelligence
Decision Tree Introduction with example
Segment Tree | Set 1 (Sum of given range)
Ordered Set and GNU C++ PBDS
Disjoint Set Data Structures
A program to check if a binary tree is BST or not
Sorted Array to Balanced BST
Optimal Binary Search Tree | DP-24
Inorder Successor in Binary Search Tree
Find the node with minimum value in a Binary Search Tree