BST vs Hash Map Trade-offs for Ordered Data in DSA C - Complexity Comparison

Time Complexity: BST vs Hash Map Trade-offs for Ordered Data

O(log n) for BST, O(1) average for Hash Map

Understanding Time Complexity

We want to understand how fast different data structures work when storing and finding data.

Which one is better for ordered data: a Binary Search Tree or a Hash Map?

Scenario Under Consideration

Analyze the time complexity of these operations on BST and Hash Map.

// Insert and search in BST
void bst_insert(Node** root, int key) {
    if (*root == NULL) {
        *root = create_node(key);
        return;
    }
    if (key < (*root)->key) bst_insert(&(*root)->left, key);
    else bst_insert(&(*root)->right, key);
}

Node* bst_search(Node* root, int key) {
    if (root == NULL || root->key == key) return root;
    if (key < root->key) return bst_search(root->left, key);
    else return bst_search(root->right, key);
}

// Hash Map insert and search (simplified)
void hashmap_insert(HashMap* map, int key) {
    int index = hash(key) % map->size;
    add_to_bucket(&map->buckets[index], key);
}

bool hashmap_search(HashMap* map, int key) {
    int index = hash(key) % map->size;
    return bucket_contains(&map->buckets[index], key);
}
    

This code shows how we insert and search keys in a BST and a Hash Map.

Identify Repeating Operations

Look at what repeats when we insert or search:

• Primary operation: Comparing keys and moving down the tree in BST; computing hash and checking bucket in Hash Map.
• How many times: In BST, up to the height of the tree; in Hash Map, depends on bucket size (usually small).

How Execution Grows With Input

As we add more data (n):

Input Size (n)	BST Operations	Hash Map Operations
10	About 3-4 comparisons (height)	About 1-2 bucket checks
100	About 6-7 comparisons	Still about 1-2 bucket checks
1000	About 10 comparisons	Still about 1-2 bucket checks

BST operations grow slowly with input size (logarithmic), Hash Map operations stay almost constant on average.

Final Time Complexity

Time Complexity: O(log n) for BST, O(1) average for Hash Map

BST takes longer as data grows but keeps order; Hash Map is faster but unordered.

Common Mistake

[X] Wrong: "Hash Maps always work faster than BSTs in every case."

[OK] Correct: Hash Maps can slow down if many keys go to the same bucket, and they don't keep data ordered like BSTs do.

Interview Connect

Knowing these trade-offs helps you pick the right tool for the job and explain your choice clearly in interviews.

Self-Check

"What if the BST is not balanced? How would that affect the time complexity compared to a Hash Map?"

Practice

1. Which data structure is best suited for maintaining data in sorted order with efficient range queries?

easy

A. Hash Map

B. Stack

C. Binary Search Tree (BST)

D. Queue

Solution

1. Step 1: Understand data ordering requirements

   Range queries and sorted data require maintaining order among elements.

2. Step 2: Compare BST and Hash Map for ordering

   BST keeps elements in sorted order by design; Hash Map does not maintain order.

3. Final Answer:

   Binary Search Tree (BST) -> Option C

4. Quick Check:

   Ordered data = BST [OK]

Hint: For sorted data and range queries, choose BST [OK]

Common Mistakes:

• Thinking hash maps maintain order
• Confusing stack or queue as ordered structures
• Ignoring the need for range queries

2. Which of the following is the correct way to declare a hash map in C using standard libraries?

easy

A. #include \nhash_map map;

B. #include \nstruct hashmap map;

C. #include \nint map[100];

D. #include \nGHashTable *map = g_hash_table_new(g_int_hash, g_int_equal);

Solution

1. Step 1: Identify standard C hash map usage

   C standard library does not have built-in hash maps; GLib provides GHashTable.

2. Step 2: Check options for valid syntax

   #include <glib.h>\nGHashTable *map = g_hash_table_new(g_int_hash, g_int_equal); uses GLib's GHashTable correctly; others are invalid or incomplete.

3. Final Answer:

   #include <glib.h>\nGHashTable *map = g_hash_table_new(g_int_hash, g_int_equal); -> Option D

4. Quick Check:

   GLib hash map syntax = #include <glib.h>\nGHashTable *map = g_hash_table_new(g_int_hash, g_int_equal); [OK]

Hint: Use GLib for hash maps in C, not standard library [OK]

Common Mistakes:

• Assuming C has built-in hash map
• Using C++ syntax in C code
• Confusing arrays with hash maps

3. Consider the following code snippet using a BST and a hash map for storing integer keys. What will be the output of the in-order traversal of the BST after inserting keys 5, 3, 7, 2, 4?

medium

A. 2 -> 3 -> 4 -> 5 -> 7 -> null

B. 5 -> 3 -> 7 -> 2 -> 4 -> null

C. 7 -> 5 -> 4 -> 3 -> 2 -> null

D. 3 -> 2 -> 4 -> 5 -> 7 -> null

Solution

1. Step 1: Insert keys into BST

   Insert 5 as root, then 3 left of 5, 7 right of 5, 2 left of 3, 4 right of 3.

2. Step 2: Perform in-order traversal

   In-order visits left subtree, root, right subtree: 2, 3, 4, 5, 7.

3. Final Answer:

   2 -> 3 -> 4 -> 5 -> 7 -> null -> Option A

4. Quick Check:

   In-order BST traversal = sorted keys [OK]

Hint: In-order traversal of BST gives sorted keys [OK]

Common Mistakes:

• Confusing insertion order with traversal order
• Mixing pre-order or post-order traversal
• Assuming hash map order applies to BST

4. The following C code attempts to insert keys into a BST but causes a runtime error. What is the main issue?

typedef struct Node {
  int key;
  struct Node *left, *right;
} Node;

Node* insert(Node* root, int key) {
  if (root == NULL) {
    Node* newNode = malloc(sizeof(Node));
    newNode->key = key;
    return newNode;
  }
  if (key < root->key)
    root->left = insert(root->left, key);
  else
    root->right = insert(root->right, key);
  return root;
}

medium

A. newNode's left and right pointers are not initialized

B. malloc is not included via stdlib.h

C. The function does not handle duplicate keys

D. The root pointer is not updated in main

Solution

1. Step 1: Check new node initialization

   newNode's left and right pointers are not set, so they contain garbage values.

2. Step 2: Understand impact on BST

   Uninitialized pointers cause undefined behavior or runtime errors during traversal or further insertions.

3. Final Answer:

   newNode's left and right pointers are not initialized -> Option A

4. Quick Check:

   Initialize pointers to NULL to avoid errors [OK]

Hint: Always initialize new node pointers to NULL [OK]

Common Mistakes:

• Ignoring pointer initialization
• Assuming malloc auto-initializes memory
• Confusing duplicate key handling with runtime error

5. You need to store a large dataset of user IDs with associated scores. You want to quickly find users with scores in a specific range and also retrieve scores by user ID efficiently. Which combination of data structures is best?

hard

A. Use only a hash map keyed by user ID

B. Use a hash map for user ID to score and a balanced BST keyed by score for range queries

C. Use only a BST keyed by user ID

D. Use an array sorted by user ID

Solution

1. Step 1: Identify requirements

   Fast lookup by user ID and efficient range queries by score are needed.

2. Step 2: Match data structures to needs

   Hash map gives O(1) user ID lookup; balanced BST keyed by score supports range queries efficiently.

3. Step 3: Combine for best performance

   Using both structures together meets both requirements effectively.

4. Final Answer:

   Use a hash map for user ID to score and a balanced BST keyed by score for range queries -> Option B

5. Quick Check:

   Hash map + BST combo = best for lookup + range [OK]

Hint: Combine hash map for lookup and BST for range queries [OK]

Common Mistakes:

• Using only one structure and missing efficiency
• Using array which is slow for lookups
• Ignoring need for range queries