Growing with the Web

AVL tree

Published , updated
Tags:

The AVL tree, named after its inventors Georgy Adelson-Velsky and Evgenii Landis, is a type of self-balancing binary search tree. The tree re-organises itself after every insert and delete so that the tree height is approximately \log n nodes high, allowing search in O(\log n) time. The re-organising does not guarantee a perfectly balanced tree, it is however good enough to guarantee O(\log n) search.

The AVL tree is similar to the self-balancing red-black tree, but instead of augmenting a binary search tree with a colour to help it achieve it’s balancing goals, it keeps track of the height of each node. When the height of the node’s children are not balanced, a rebalancing operation is performed.

This article assumes knowledge of the binary search tree (BST) data structure.

Complexity

Operation Description Complexity
Delete Deletes a node given a key O(\log n)
Insert Inserts a node with an associated key O(\log n)
Search Searches for and returns a node using its key O(\log n)

Properties

An AVL tree is a BST with the following additional property:

  • Each node’s children differ in height by at most 1; |h_l - h_r| \leq 1

Representation

There are two main ways of representing a binary tree. The first is using node objects that have references to their children.

Tree representation

The second is using a regular array and manipulating the index of the node to find its children. The index of the left child of a node is 2i + 1 and the index of the right is 2i + 2 where i is the index of the parent.

Array representation

The index of node's parent can also be retrieved with \lfloor(i - 1) / 2\rfloor.

Height of a node

The height of a node is defined as the maximum number of steps from the node to any of its leaf nodes. This can be defined recursively as h = max(h_l, h_r) + 1, with the base case being a h = 0 for a leaf node.

This is not to be confused with the depth of a node which is the number of steps from the tree’s root.

A helpful implementation detail is to define children that don’t exist as having a height of -1, this allows the balance function defined in the properties section to work on nodes with 0 or 1 children.

Balancing operations

When insertion or deletion occurs, the heights of nodes are updated and a balancing operation occurs. There are four different cases that can occur, each of them can be fixed using either one or two binary tree rotation operations.

Left left case

This case occurs when the height of a node’s left child becomes 2 greater than that of the right child, and the left child is either balanced or left-heavy. It can be fixed using a single right rotate operation on the unbalanced node.

Left right case

This case occurs when the height of a node’s left child becomes 2 greater than that of the right child, and the left child is right-heavy. It can be fixed using a left rotate on the left child, which results in the left left case which is fixed using a right rotate on the unbalanced node.

Right right case

This case occurs when the height of a node’s right child becomes 2 greater than that of the left child, and the right child is either balanced or right-heavy. This is the inverse of the left left case. It can be fixed using a single left rotate operation on the unbalanced node.

Right left case

This case occurs when the height of a node’s right child becomes 2 greater than that of the left child, and the right child is left-heavy. This is the inverse of the left right case. It can be fixed using a right rotate on the right child, which results in the right right case which is fixed using a left rotate on the unbalanced node.

Operations

Delete

Delete starts by performing a regular BST delete. Once the node is deleted, go up the tree updating the heights of each node and rebalancing when required as outlined in the balancing section.

Insert

Insert starts by performing a regular BST insert. Once the node is inserted, go up the tree updating the heights of each node and rebalancing when required as outlined in the balancing section.

Search simply performs a BST search since the AVL maintains BST properties.

Worst case balancing

The worst case balancing of the AVL tree occurs when one child on every node has a height of 1 more than the other child.

Examples of worst case balanced AVL trees of heights 1, 2 and 3

Notice how the example of a tree of height 3 is a node with the left child being the height 2 tree and right child being the height 1 tree. This illustrates the recurrence for the worst case height of a tree.

F_h = F_{h-1} + F_{h-2} + 1

It’s easy to see the worst case height formula in action by highlighting the sub-trees.

A visual example of the recurrence

This recurrence is very similar to the Fibonacci sequence; F_n = F_{n-1} + F_{n-2}. Fortunately, just like the Fibonacci sequence, the number of nodes in a worst case balanced AVL tree increases exponentially. This means that the worst case height is still O(\log n) even in a worst case balanced tree.

Which binary search tree is best?

The AVL tree, red-black tree and splay tree are all self-adjusting binary search trees, so which one is better in which situation? And when is it better to use a regular BST?

A paper by Ben Pfaff of Stanford University performs an in-depth study of the performance characteristics of each tree under various circumstances. Each data structure excels based on runtime patterns in the input and the calling of operations. It comes to the following conclusions:

  • Regular BSTs excel when randomly ordered input can be relied upon.
  • Splay trees excel when data is often inserted in a sorted order and later accesses are sequential or clustered.
  • AVL trees excel when data is often inserted in a sorted order and later accesses are random.
  • Red-black trees excel when data is often inserted in random order but occasional runs of sorted order are expected.

Code

/**
 * Generic implementation of an AVL tree.
 */
public class AVLTree<K extends Comparable<K>> implements BinarySearchTreeInterface<K> {
    /**
     * The root of the tree.
     */
    private AVLTreeNode root;

    /**
     * The size of the tree.
     */
    private int size = 0;

    /**
     * Creates a new {@link AVLTree}.
     */
    public AVLTree() { }

    /** {@inheritDoc} */
    public void insert(K key) {
        root = insert(key, root);
        size++;
    }

    /**
     * Inserts a new node with a specific key into the tree.
     *
     * @param key The key being inserted.
     * @param root The root of the tree to insert in.
     * @return The new tree root.
     */
    private AVLTreeNode insert(K key, AVLTreeNode<K> root) {
        // Perform regular BST insertion
        if (root == null) {
            return new AVLTreeNode(key);
        }

        if (key.compareTo(root.getKey()) < 0) {
            root.setLeft(insert(key, root.getLeft()));
        } else if (key.compareTo(root.getKey()) > 0) {
            root.setRight(insert(key, root.getRight()));
        } else {
            // It's a duplicate so insertion failed, decrement size to make up for it
            size--;
            return root;
        }

        // Update height and rebalance tree
        root.setHeight(Math.max(root.getLeftHeight(), root.getRightHeight()) + 1);
        BalanceState balanceState = getBalanceState(root);

        if (balanceState == BalanceState.UNBALANCED_LEFT) {
            if (key.compareTo(root.getLeft().getKey()) < 0) {
                // Left left case
                root = root.rotateRight();
            } else {
                // Left right case
                root.setLeft(root.getLeft().rotateLeft());
                return root.rotateRight();
            }
        }

        if (balanceState == BalanceState.UNBALANCED_RIGHT) {
            if (key.compareTo(root.getRight().getKey()) > 0) {
                // Right right case
                root = root.rotateLeft();
            } else {
                // Right left case
                root.setRight(root.getRight().rotateRight());
                return root.rotateLeft();
            }
        }

        return root;
    }

    /** {@inheritDoc} */
    public void delete(K key) {
        root = delete(key, root);
        size--;
    }

    /**
     * Deletes a node with a specific key from the tree.
     *
     * @param key The key being deleted.
     * @param root The root of the tree to delete from.
     * @return The new tree root.
     */
    private AVLTreeNode delete(K key, AVLTreeNode<K> root) {
        // Perform regular BST deletion
        if (root == null) {
            size++;
            return root;
        }

        if (key.compareTo(root.getKey()) < 0) {
            // The key to be deleted is in the left sub-tree
            root.setLeft(delete(key, root.getLeft()));
        } else if (key.compareTo(root.getKey()) > 0) {
            // The key to be deleted is in the right sub-tree
            root.setRight(delete(key, root.getRight()));
        } else {
            // root is the node to be deleted
            if (!root.leftExists() && !root.rightExists()) {
                root = null;
            } else if (!root.leftExists() && root.rightExists()) {
                root = root.getRight();
            } else if (root.leftExists() && !root.rightExists()) {
                root = root.getLeft();
            } else {
                // Node has 2 children, get the in-order successor
                AVLTreeNode<K> inOrderSuccessor = minValueNode(root.getRight());
                root.setKey(inOrderSuccessor.getKey());
                root.setRight(delete(inOrderSuccessor.getKey(), root.getRight()));
            }
        }

        if (root == null) {
            return root;
        }

        // Update height and rebalance tree
        root.setHeight(Math.max(root.getLeftHeight(), root.getRightHeight()) + 1);
        BalanceState balanceState = getBalanceState(root);

        if (balanceState == BalanceState.UNBALANCED_LEFT) {
            // Left left case
            if (getBalanceState(root.getLeft()) == BalanceState.BALANCED ||
                    getBalanceState(root.getLeft()) == BalanceState.SLIGHTLY_UNBALANCED_LEFT) {
                return root.rotateRight();
            }
            // Left right case
            if (getBalanceState(root.getLeft()) == BalanceState.SLIGHTLY_UNBALANCED_RIGHT) {
                root.setLeft(root.getLeft().rotateLeft());
                return root.rotateRight();
            }
        }

        // Right right case
        if (balanceState == BalanceState.UNBALANCED_RIGHT) {
            if (getBalanceState(root.getLeft()) == BalanceState.BALANCED ||
                    getBalanceState(root.getLeft()) == BalanceState.SLIGHTLY_UNBALANCED_RIGHT) {
                return root.rotateLeft();
            }
            // Right left case
            if (getBalanceState(root.getLeft()) == BalanceState.SLIGHTLY_UNBALANCED_LEFT) {
                root.setRight(root.getRight().rotateRight());
                return root.rotateLeft();
            }
        }

        return root;
    }

    /** {@inheritDoc} */
    public boolean contains(K key) {
        if (root == null) {
            return false;
        }

        return contains(key, root);
    }

    /**
     * Gets whether a node with a specific key is within the tree.
     *
     * @param key The key being searched for.
     * @param root The root of the tree to search in.
     * @return Whether a node with the key exists.
     */
    private boolean contains(K key, AVLTreeNode<K> root) {
        if (key == root.getKey()) {
            return true;
        }

        if (key.compareTo(root.getKey()) < 0) {
            if (!root.leftExists()) {
                return false;
            }
            return contains(key, root.getLeft());
        }

        if (key.compareTo(root.getKey()) > 0) {
            if (!root.rightExists()) {
                return false;
            }
            return contains(key, root.getRight());
        }

        return false;
    }

    /**
     * @return The minimum key in the tree.
     */
    public K findMinimum() {
        return minValueNode(root).getKey();
    }

    /**
     * Gets the minimum value node, rooted in a particular node.
     *
     * @param root The node to search.
     * @return The node with the minimum key in the tree.
     */
    private AVLTreeNode<K> minValueNode(AVLTreeNode<K> root) {
        AVLTreeNode<K> current = root;
        while (current.leftExists()) {
            current = current.getLeft();
        }
        return current;
    }

    /**
     * @return The maximum key in the tree.
     */
    public K findMaximum() {
        return maxValueNode(root).getKey();
    }

    /**
     * Gets the maximum value node, rooted in a particular node.
     *
     * @param root The node to search.
     * @return The node with the maximum key in the tree.
     */
    private AVLTreeNode<K> maxValueNode(AVLTreeNode<K> root) {
        AVLTreeNode<K> current = root;
        while (current.rightExists()) {
            current = current.getRight();
        }
        return current;
    }

    /** {@inheritDoc} */
    public int size() {
        return size;
    }

    /** {@inheritDoc} */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * Gets the balance state of a node, indicating whether the left or right sub-trees are
     * unbalanced.
     *
     * @param node The node to get the difference from.
     * @return The {@link BalanceState} of the node.
     */
    private static BalanceState getBalanceState(AVLTreeNode node) {
        if (node == null) {
            return BalanceState.BALANCED;
        }
        int heightDifference = node.getLeftHeight() - node.getRightHeight();
        switch (heightDifference) {
            case -2: return BalanceState.UNBALANCED_RIGHT;
            case -1: return BalanceState.SLIGHTLY_UNBALANCED_RIGHT;
            case 1: return BalanceState.SLIGHTLY_UNBALANCED_LEFT;
            case 2: return BalanceState.UNBALANCED_LEFT;
        }
        return BalanceState.BALANCED;
    }

    /**
     * Represents how balanced a node's left and right children are.
     */
    private enum BalanceState {
        UNBALANCED_RIGHT,
        SLIGHTLY_UNBALANCED_RIGHT,
        BALANCED,
        SLIGHTLY_UNBALANCED_LEFT,
        UNBALANCED_LEFT
    }
}



/**
 * Generic implementation of an AVL tree node.
 */
public class AVLTreeNode<K extends Comparable<K>> implements Comparable<AVLTreeNode<K>> {
    /**
     * The height of a left or right child node that doesn't exist.
     */
    private static final int NULL_NODE_HEIGHT = -1;

    /**
     * The left child node.
     */
    private AVLTreeNode<K> left;

    /**
     * The right child node.
     */
    private AVLTreeNode<K> right;

    /**
     * The key of the node.
     */
    private K key;

    /**
     * The height of the node.
     */
    private int height;

    /**
     * Creates a new {@link AVLTreeNode}.
     *
     * @param key The key of the new node.
     */
    public AVLTreeNode(K key) {
        this.key = key;
    }

    /**
     * @return Whether the node has a left child.
     */
    public boolean leftExists() {
        return left != null;
    }

    /**
     * @return Whether the node has a right child.
     */
    public boolean rightExists() {
        return right != null;
    }

    /**
     * @return The key of this node.
     */
    public K getKey() {
        return key;
    }

    /**
     * Sets the key of this node.
     *
     * @param key The new key.
     */
    public void setKey(K key) {
        this.key = key;
    }

    /**
     * @return The left child node.
     */
    public AVLTreeNode<K> getLeft() {
        return left;
    }

    /**
     * Sets the left child node.
     *
     * @param left The new left child node.
     */
    public void setLeft(AVLTreeNode<K> left) {
        this.left = left;
    }

    /**
     * @return The right child node.
     */
    public AVLTreeNode<K> getRight() {
        return right;
    }

    /**
     * Sets the right child node.
     *
     * @param right The new right child node.
     */
    public void setRight(AVLTreeNode<K> right) {
        this.right = right;
    }

    /**
     * @return The height of the node.
     */
    public int getHeight() {
        return height;
    }

    /**
     * Sets the height of the node.
     *
     * @param height The new height of the node.
     */
    public void setHeight(int height) {
        this.height = height;
    }


    /**
     * Performs a right rotate on this node.
     *
     *       b                           a
     *      / \                         / \
     *     a   e -> b.rotateRight() -> c   b
     *    / \                             / \
     *   c   d                           d   e
     *
     * @return The root of the sub-tree; the node where this node used to be.
     */
    public AVLTreeNode<K> rotateRight() {
        AVLTreeNode<K> other = getLeft();
        setLeft(other.getRight());
        other.setRight(this);
        setHeight(Math.max(this.getLeftHeight(), this.getRightHeight()) + 1);
        other.setHeight(Math.max(other.getLeftHeight(), this.getHeight()) + 1);
        return other;
    }

    /**
     * Performs a left rotate on this node.
     *
     *     a                              b
     *    / \                            / \
     *   c   b   -> a.rotateLeft() ->   a   e
     *      / \                        / \
     *     d   e                      c   d
     *
     * @return The root of the sub-tree; the node where this node used to be.
     */
    public AVLTreeNode<K> rotateLeft() {
        AVLTreeNode<K> other = getRight();
        setRight(other.getLeft());
        other.setLeft(this);
        setHeight(Math.max(this.getLeftHeight(), this.getRightHeight()) + 1);
        other.setHeight(Math.max(other.getRightHeight(), this.getHeight()) + 1);
        return other;
    }

    /**
     * Convenience function to get the height of the left child of the node, returning
     * {@link NULL_NODE_HEIGHT} if the node is null.
     *
     * @return The height of the left child, or {@link NULL_NODE_HEIGHT} if it doesn't exist.
     */
    public int getLeftHeight() {
        if (!leftExists()) {
            return NULL_NODE_HEIGHT;
        }
        return getLeft().getHeight();
    }

    /**
     * Convenience function to get the height of the right child of the node, returning
     * {@link NULL_NODE_HEIGHT} if the node is null.
     *
     * @return The height of the right child, or {@link NULL_NODE_HEIGHT} if it doesn't exist.
     */
    public int getRightHeight() {
        if (!rightExists()) {
            return NULL_NODE_HEIGHT;
        }
        return getRight().getHeight();
    }

    /** {@inheritDoc} */
    @Override
    public int compareTo(AVLTreeNode<K> o) {
        return key.compareTo(o.key);
    }
}



/**
 * An interface for data structures that support binary search tree operations.
 */
public interface BinarySearchTreeInterface<K> {
    /**
     * Inserts a new node with a specific key into the tree.
     *
     * @param key The key being inserted.
     */
    void insert(K key);

    /**
     * Deletes a node with a specific key from the tree.
     *
     * @param key The key being deleted.
     */
    void delete(K key);

    /**
     * Gets whether a node with a specific key is within the tree.
     *
     * @param key The key being searched for.
     * @return Whether a node with the key exists.
     */
    boolean contains(K key);

    /**
     * @return The size of the tree.
     */
    int size();

    /**
     * @return Whether the tree is empty; the size of the tree is 0).
     */
    boolean isEmpty();
}
/**
 * Creates a new AVL Tree.
 *
 * @param {function} customCompare An optional custom compare function.
 */
var AvlTree = function (customCompare) {
  this._root = null;
  this._size = 0;

  if (customCompare) {
    this._compare = customCompare;
  }
};

/**
 * Compares two keys with each other.
 *
 * @private
 * @param {Object} a The first key to compare.
 * @param {Object} b The second key to compare.
 * @return {number} -1, 0 or 1 if a < b, a == b or a > b respectively.
 */
AvlTree.prototype._compare = function (a, b) {
  if (a > b) {
    return 1;
  }
  if (a < b) {
    return -1;
  }
  return 0;
};

/**
 * Inserts a new node with a specific key into the tree.
 *
 * @param {Object} key The key being inserted.
 * @param {Object} value The value being inserted.
 */
AvlTree.prototype.insert = function (key, value) {
  this._root = this._insert(key, value, this._root);
  this._size++;
};

/**
 * Inserts a new node with a specific key into the tree.
 *
 * @private
 * @param {Object} key The key being inserted.
 * @param {Node} root The root of the tree to insert in.
 * @return {Node} The new tree root.
 */
AvlTree.prototype._insert = function (key, value, root) {
  // Perform regular BST insertion
  if (root === null) {
    return new Node(key, value);
  }

  if (this._compare(key, root.key) < 0) {
    root.left = this._insert(key, value, root.left);
  } else if (this._compare(key, root.key) > 0) {
    root.right = this._insert(key, value, root.right);
  } else {
    // It's a duplicate so insertion failed, decrement size to make up for it
    this._size--;
    return root;
  }

  // Update height and rebalance tree
  root.height = Math.max(root.leftHeight(), root.rightHeight()) + 1;
  var balanceState = getBalanceState(root);

  if (balanceState === BalanceState.UNBALANCED_LEFT) {
    if (this._compare(key, root.left.key) < 0) {
      // Left left case
      root = root.rotateRight();
    } else {
      // Left right case
      root.left = root.left.rotateLeft();
      return root.rotateRight();
    }
  }

  if (balanceState === BalanceState.UNBALANCED_RIGHT) {
    if (this._compare(key, root.right.key) > 0) {
      // Right right case
      root = root.rotateLeft();
    } else {
      // Right left case
      root.right = root.right.rotateRight();
      return root.rotateLeft();
    }
  }

  return root;
};

/**
 * Deletes a node with a specific key from the tree.
 *
 * @param {Object} key The key being deleted.
 */
AvlTree.prototype.delete = function (key) {
  this._root = this._delete(key, this._root);
  this._size--;
};

/**
 * Deletes a node with a specific key from the tree.
 *
 * @private
 * @param {Object} key The key being deleted.
 * @param {Node} root The root of the tree to delete from.
 * @return {Node} The new tree root.
 */
AvlTree.prototype._delete = function (key, root) {
  // Perform regular BST deletion
  if (root === null) {
    this._size++;
    return root;
  }

  if (this._compare(key, root.key) < 0) {
    // The key to be deleted is in the left sub-tree
    root.left = this._delete(key, root.left);
  } else if (this._compare(key, root.key) > 0) {
    // The key to be deleted is in the right sub-tree
    root.right = this._delete(key, root.right);
  } else {
    // root is the node to be deleted
    if (!root.left && !root.right) {
      root = null;
    } else if (!root.left && root.right) {
      root = root.right;
    } else if (root.left && !root.right) {
      root = root.left;
    } else {
      // Node has 2 children, get the in-order successor
      var inOrderSuccessor = minValueNode(root.right);
      root.key = inOrderSuccessor.key;
      root.right = this._delete(inOrderSuccessor.key, root.right);
    }
  }

  if (root === null) {
    return root;
  }

  // Update height and rebalance tree
  root.height = Math.max(root.leftHeight(), root.rightHeight()) + 1;
  var balanceState = getBalanceState(root);

  if (balanceState === BalanceState.UNBALANCED_LEFT) {
    // Left left case
    if (getBalanceState(root.left) === BalanceState.BALANCED ||
        getBalanceState(root.left) === BalanceState.SLIGHTLY_UNBALANCED_LEFT) {
      return root.rotateRight();
    }
    // Left right case
    if (getBalanceState(root.left) === BalanceState.SLIGHTLY_UNBALANCED_RIGHT) {
      root.left = root.left.rotateLeft();
      return root.rotateRight();
    }
  }

  if (balanceState === BalanceState.UNBALANCED_RIGHT) {
    // Right right case
    if (getBalanceState(root.right) === BalanceState.BALANCED ||
        getBalanceState(root.right) === BalanceState.SLIGHTLY_UNBALANCED_RIGHT) {
      return root.rotateLeft();
    }
    // Right left case
    if (getBalanceState(root.right) === BalanceState.SLIGHTLY_UNBALANCED_LEFT) {
      root.right = root.right.rotateRight();
      return root.rotateLeft();
    }
  }

  return root;
};

/**
 * Gets the value of a node within the tree with a specific key.
 *
 * @param {Object} key The key being searched for.
 * @return {Object} The value of the node or null if it doesn't exist.
 */
AvlTree.prototype.get = function (key) {
  if (this._root === null) {
    return null;
  }

  return this._get(key, this._root).value;
};

/**
 * Gets the value of a node within the tree with a specific key.
 *
 * @private
 * @param {Object} key The key being searched for.
 * @param {Node} root The root of the tree to search in.
 * @return {Object} The value of the node or null if it doesn't exist.
 */
AvlTree.prototype._get = function (key, root) {
  if (key === root.key) {
    return root;
  }

  if (this._compare(key, root.key) < 0) {
    if (!root.left) {
      return null;
    }
    return this._get(key, root.left);
  }

  if (!root.right) {
    return null;
  }
  return this._get(key, root.right);
};

/**
 * Gets whether a node with a specific key is within the tree.
 *
 * @param {Object} key The key being searched for.
 * @return {boolean} Whether a node with the key exists.
 */
AvlTree.prototype.contains = function (key) {
  if (this._root === null) {
    return false;
  }

  return !!this._get(key, this._root);
};

/**
 * @return {Object} The minimum key in the tree.
 */
AvlTree.prototype.findMinimum = function () {
  return minValueNode(this._root).key;
};

/**
 * Gets the minimum value node, rooted in a particular node.
 *
 * @private
 * @param {Node} root The node to search.
 * @return {Node} The node with the minimum key in the tree.
 */
function minValueNode(root) {
  var current = root;
  while (current.left) {
    current = current.left;
  }
  return current;
}

/**
 * @return {Object} The maximum key in the tree.
 */
AvlTree.prototype.findMaximum = function () {
  return maxValueNode(this._root).key;
};

/**
 * Gets the maximum value node, rooted in a particular node.
 *
 * @private
 * @param {Node} root The node to search.
 * @return {Node} The node with the maximum key in the tree.
 */
function maxValueNode(root) {
  var current = root;
  while (current.right) {
    current = current.right;
  }
  return current;
}

/**
 * @return {number} The size of the tree.
 */
AvlTree.prototype.size = function () {
  return this._size;
};

/**
 * @return {boolean} Whether the tree is empty.
 */
AvlTree.prototype.isEmpty = function () {
  return this._size === 0;
};

/**
 * Represents how balanced a node's left and right children are.
 *
 * @private
 */
var BalanceState = {
  UNBALANCED_RIGHT: 1,
  SLIGHTLY_UNBALANCED_RIGHT: 2,
  BALANCED: 3,
  SLIGHTLY_UNBALANCED_LEFT: 4,
  UNBALANCED_LEFT: 5
};

/**
 * Gets the balance state of a node, indicating whether the left or right
 * sub-trees are unbalanced.
 *
 * @private
 * @param {Node} node The node to get the difference from.
 * @return {BalanceState} The BalanceState of the node.
 */
function getBalanceState(node) {
  var heightDifference = node.leftHeight() - node.rightHeight();
  switch (heightDifference) {
    case -2: return BalanceState.UNBALANCED_RIGHT;
    case -1: return BalanceState.SLIGHTLY_UNBALANCED_RIGHT;
    case 1: return BalanceState.SLIGHTLY_UNBALANCED_LEFT;
    case 2: return BalanceState.UNBALANCED_LEFT;
    default: return BalanceState.BALANCED;
  }
}



/**
 * Creates a new AVL Tree node.
 *
 * @private
 * @param {Object} key The key of the new node.
 * @param {Object} value The value of the new node.
 */
var Node = function (key, value) {
  this.left = null;
  this.right = null;
  this.height = null;
  this.key = key;
  this.value = value;
};

/**
 * Performs a right rotate on this node.
 *
 *       b                           a
 *      / \                         / \
 *     a   e -> b.rotateRight() -> c   b
 *    / \                             / \
 *   c   d                           d   e
 *
 * @return {Node} The root of the sub-tree; the node where this node used to be.
 */
Node.prototype.rotateRight = function () {
  var other = this.left;
  this.left = other.right;
  other.right = this;
  this.height = Math.max(this.leftHeight(), this.rightHeight()) + 1;
  other.height = Math.max(other.leftHeight(), this.height) + 1;
  return other;
};

/**
 * Performs a left rotate on this node.
 *
 *     a                              b
 *    / \                            / \
 *   c   b   -> a.rotateLeft() ->   a   e
 *      / \                        / \
 *     d   e                      c   d
 *
 * @return {Node} The root of the sub-tree; the node where this node used to be.
 */
Node.prototype.rotateLeft = function () {
  var other = this.right;
  this.right = other.left;
  other.left = this;
  this.height = Math.max(this.leftHeight(), this.rightHeight()) + 1;
  other.height = Math.max(other.rightHeight(), this.height) + 1;
  return other;
};

/**
 * Convenience function to get the height of the left child of the node,
 * returning -1 if the node is null.
 *
 * @return {number} The height of the left child, or -1 if it doesn't exist.
 */
Node.prototype.leftHeight = function () {
  if (!this.left) {
    return -1;
  }
  return this.left.height;
};

/**
 * Convenience function to get the height of the right child of the node,
 * returning -1 if the node is null.
 *
 * @return {number} The height of the right child, or -1 if it doesn't exist.
 */
Node.prototype.rightHeight = function () {
  if (!this.right) {
    return -1;
  }
  return this.right.height;
};

References

  • T.H. Cormen, C.E. Leiserson, R.L. Rivest, C. Stein, “Red-Black Trees” in Introduction to Algorithms, 2nd ed., Cambridge, MA: The MIT Press, 2001, ch. 13, sec. 3, p.296
  • B. Pfaff and Stanford University Department of Computer Science (2004, Jun.), Performance Analysis of BSTs in System Software [Online]. Available: http://www.stanford.edu/~blp/papers/libavl.pdf

Comments

comments powered by Disqus
Like this article?
Subscribe for more!