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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert a new node into a Binary Search Tree (BST).

DSA C

struct Node* insert(struct Node* root, int key) {
    if (root == NULL) {
        root = (struct Node*)malloc(sizeof(struct Node));
        root->key = key;
        root->left = root->right = NULL;
        return root;
    }
    if (key [1] root->key) {
        root->left = insert(root->left, key);
    } else if (key > root->key) {
        root->right = insert(root->right, key);
    }
    return root;
}

Drag options to blanks, or click blank then click option'

A<

B<=

C>=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= instead of < causes duplicates on the left.

Using == in comparison is incorrect for insertion.

In a BST, keys less than the current node go to the left subtree, so we use < to decide where to insert.

2fill in blank

medium

Complete the code to check if a key exists in a hash map using chaining.

DSA C

int contains(struct HashMap* map, int key) {
    int index = key % map->capacity;
    struct Node* current = map->buckets[index];
    while (current != NULL) {
        if (current->key [1] key) {
            return 1;
        }
        current = current->next;
    }
    return 0;
}

Drag options to blanks, or click blank then click option'

A==

B!=

C<

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using != causes wrong results by skipping matching keys.

Using < or > is not meaningful for equality check.

To find a key in a hash map bucket, we check if the current node's key equals the searched key.

3fill in blank

hard

Fix the error in the BST search function to correctly find a key.

DSA C

struct Node* search(struct Node* root, int key) {
    if (root == NULL || root->key [1] key) {
        return root;
    }
    if (key < root->key) {
        return search(root->left, key);
    } else {
        return search(root->right, key);
    }
}

Drag options to blanks, or click blank then click option'

A!=

B<

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using != causes the function to return early incorrectly.

Using < or > in base case is wrong logic.

The base case returns the node if its key equals the searched key, so use ==.

4fill in blank

hard

Fill both blanks to create a hash map insertion that handles collisions by chaining.

DSA C

void insert(struct HashMap* map, int key) {
    int index = key [1] map->capacity;
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->key = key;
    newNode->next = map->buckets[[2]];
    map->buckets[index] = newNode;
}

Drag options to blanks, or click blank then click option'

A%

Bindex

Ckey

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using * instead of % causes wrong bucket index.

Using key instead of index for bucket access causes errors.

Use modulo (%) to find the bucket index, then insert the new node at the head of that bucket's linked list.

5fill in blank

hard

Fill all three blanks to create a function that prints BST keys in ascending order.

DSA C

void inorder(struct Node* root) {
    if (root == NULL) return;
    inorder(root->[1]);
    printf("%d ", root->[2]);
    inorder(root->[3]);
}

Drag options to blanks, or click blank then click option'

Aleft

Bkey

Cright

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Visiting right child before left causes descending order.

Printing parent or wrong field instead of key.

Inorder traversal visits left subtree, then current node's key, then right subtree to print keys in ascending order.

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