Understanding Binary Search Trees: Insertion, Deletion, and Searching

In this lecture, we delve into the concept of Binary Search Trees (BST), a crucial data structure in computer science. Having previously covered binary trees, we now focus on the properties and operations associated with BSTs, including insertion, deletion, and searching for nodes.

What is a Binary Search Tree?

A Binary Search Tree is a tree data structure where each node has at most two children. The left child contains values less than the parent node, while the right child contains values greater than the parent node. This property holds true for every node in the tree, making it efficient for searching operations.

Properties of BST

1. Node Structure: Each node contains data, a left pointer, and a right pointer.
2. Ordering: For any given node, all values in the left subtree are less than the node's value, and all values in the right subtree are greater.
3. Traversal: Inorder traversal of a BST yields sorted values.

Insertion in a Binary Search Tree

To insert a new value into a BST, we follow these steps:

1. Start at the root node.
2. Compare the value to be inserted with the current node's value.
3. If the value is less, move to the left child; if greater, move to the right child.
4. Repeat this process until you find a NULL position where the new node can be inserted.

Code Example for Insertion

class Node {
public:
    int data;
    Node* left;
    Node* right;
    Node(int d) : data(d), left(NULL), right(NULL) {}
};

void insertIntoBST(Node*& root, int d) {
    if (root == NULL) {
        root = new Node(d);
        return;
    }
    if (d < root->data) {
        insertIntoBST(root->left, d);
    } else {
        insertIntoBST(root->right, d);
    }
}

Searching in a Binary Search Tree

Searching for a value in a BST is similar to insertion:

1. Start at the root node.
2. Compare the target value with the current node's value.
3. If equal, return true; if less, search the left subtree; if greater, search the right subtree.
4. If you reach a NULL node, the value is not present in the tree.

Code Example for Searching

bool searchInBST(Node* root, int x) {
    if (root == NULL) return false;
    if (root->data == x) return true;
    return (x < root->data) ? searchInBST(root->left, x) : searchInBST(root->right, x);
}

Deletion in a Binary Search Tree

Deleting a node from a BST involves three main scenarios:

1. Node with No Children: Simply remove the node.
2. Node with One Child: Remove the node and link its parent directly to its child.
3. Node with Two Children: Find the minimum value in the right subtree (or maximum in the left subtree), replace the node's value with this value, and then delete the minimum (or maximum) node.

Code Example for Deletion

Node* deleteFromBST(Node* root, int val) {
    if (root == NULL) return root;
    if (val < root->data) {
        root->left = deleteFromBST(root->left, val);
    } else if (val > root->data) {
        root->right = deleteFromBST(root->right, val);
    } else {
        // Node with one child or no child
        if (root->left == NULL) {
            Node* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == NULL) {
            Node* temp = root->left;
            delete root;
            return temp;
        }
        // Node with two children
        Node* temp = minValueNode(root->right);
        root->data = temp->data;
        root->right = deleteFromBST(root->right, temp->data);
    }
    return root;
}

Complexity Analysis

• Insertion Complexity: O(log n) on average, O(n) in the worst case (unbalanced tree).
• Searching Complexity: O(log n) on average, O(n) in the worst case.
• Deletion Complexity: Similar to insertion and searching, O(log n) on average, O(n) in the worst case.

Conclusion

Binary Search Trees are a powerful data structure that allows for efficient searching, insertion, and deletion operations. Understanding how to implement these operations is crucial for optimizing performance in various applications. In this lecture, we covered the fundamental concepts and provided code examples to illustrate the implementation of BST operations.

As you continue to explore data structures, consider practicing these operations to solidify your understanding and prepare for potential interview questions related to BSTs.