BST (Binary Search Tree)

If you need to maintain a list of objects that are sorted and unique

& if you need to be able to quickly insert and retrieve objects to and from this list

－－ the ideal data structure will be a tree set (or a tree map, if you consider each object a key and associate another object called a value to it).

 

Implementation in Java : TreeSet<T>, TreeMap<K, V>

 

A binary tree is a BST iff, for every node n, in the tree:

• All keys in n's left subtree are less than the key in n, and
• all keys in n's right subtree are greater than the key in n.

 

Insertion - O(log n)

From root all the way to leaf, compare and decide which side to go.

The new node will always a leaf node.

 

Deletion - O(1)-O(log n)

If n has no children, we only have to remove n from the tree. 

If n has a single child, we remove n and connect its parent to its child. 

If n has two children, we need to : 

          Find the smallest node that is larger than n, call it m. 

          Remove m from the tree, Replace the value of n with m.

          (think : m will always have no left child)

 

Retrieval - O(log n)

For BST (binary search trees),

although the average-case times for the lookup, insert, and delete methods are all O(log N), where N is the number of nodes in the tree,

the worst-case time is O(N).

 

We can guarantee O(log N) time for all three methods by using a Balanced Tree -- a tree that always has height O(log N)-- instead of a binary search tree.

 

Balanced Tree — AVL tree, 2-4 tree, red-black tree and B trees

 

"fully populated" means that every internal node has exactly two children, and all terminal nodes are at the same depth. 

 

class BST {
    private class Node {
        int val;
        Node left;
        Node right;
        
        public Node() {}
        
        public Node(int val) {
            this.val = val;
        }
        
        public void copy(Node n) {
            this.val = n.val;
            this.left = n.left;
            this.right = n.right;
        }
    }
    
    public static Node root;
    
    // Insert, O(lg n)
    public void insert(int val) {
        root = insert(root, val);
    }
    
    private Node insert(Node node, int val) {
        if (node == null) {
            node = new Node(val);
            return node;
        }
        
        if (node.val > val) node.left = insert(node.left, val);
        if (node.val < val) node.right = insert(node.right, val);
        
        return node;
    }
    
    //Search, O(lg n)
    public Node search(int val) {
        return search(root, val);
    }
    
    private Node search(Node node, int val) {
        if (node == null) return null;
        
        if (node.val == val) return node;
        else if (node.val > val) return search(node.left, val);
        else return search(node.right, val);
    }
    
    //Delete, O(1) - O(lg n)
    public Node delete(int val) {
        root = delete(root, val);
        return root;
    }
    
    private Node delete(Node node, int val) {
        if (node == null) return null;
        if (node.val > val) node.left = delete(node.left, val);
        else if (node.val < val) node.right = delete(node.right, val);
        
        else {
            Node del = new Node();
            del.copy(node);
        
            if (node.left == null) {node.copy(node.right); node.right = null; return node;}
            if (node.right == null) {node.copy(node.left); node.left = null; return node;}
        
            node.copy(min(del.right));
            node.right = deleteMin(del.right);
            node.left = del.left;
        }
        return node;
    }
    
    private Node min (Node node) {
        if (node == null || node.left  == null) return node;
        return min(node.left);
    }
    
    // remove the smallest node and return new root;
    private Node deleteMin(Node node) {
        if (node == null) return null;
        if (node.left == null) {
            return node.right; // node is deleted
        }
        node.left = deleteMin(node.left);
        return node;
    }
}