BST Insert Operation in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA C

struct Node* newNode(int value) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = [1];
    node->left = NULL;
    node->right = NULL;
    return node;
}

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

Anode

Bdata

Cval

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using an undefined variable instead of 'value'.

Assigning node instead of node->data.

The new node's data field should be set to the given value parameter.

2fill in blank

medium

Complete the code to insert a value into the BST recursively.

DSA C

struct Node* insert(struct Node* root, int value) {
    if (root == NULL) {
        return newNode([1]);
    }
    if (value < root->data) {
        root->left = insert(root->left, value);
    } else if (value > root->data) {
        root->right = insert(root->right, value);
    }
    return root;
}

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

Aroot->data

BNULL

Cvalue

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Passing root->data instead of value to newNode.

Returning NULL instead of a new node.

When root is NULL, create a new node with the value to insert.

3fill in blank

hard

Fix the error in the comparison to decide where to insert the new value.

DSA C

if (value [1] root->data) {
    root->left = insert(root->left, value);
} else if (value > root->data) {
    root->right = insert(root->right, value);
}

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

A<

B>

C==

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' causes wrong subtree insertion.

Using '==' causes no insertion.

If value is less than root->data, insert into the left subtree.

4fill in blank

hard

Fill both blanks to complete the recursive insertion and return the updated root.

DSA C

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

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

AnewNode(value)

B<

C>

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Returning root instead of new node when root is NULL.

Using wrong comparison operator for left subtree.

Return a new node when root is NULL and check if value is less than root->data to go left.

5fill in blank

hard

Fill all three blanks to complete the BST insert function with proper recursion and return.

DSA C

struct Node* insert(struct Node* root, int value) {
    if (root == NULL) {
        return [1];
    }
    if (value [2] root->data) {
        root->left = insert(root->left, value);
    } else if (value [3] root->data) {
        root->right = insert(root->right, value);
    }
    return root;
}

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

AnewNode(value)

B<

C>

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong operators for comparisons.

Not returning the updated root.

Create a new node if root is NULL, insert left if value < root->data, insert right if value > root->data.

Practice

1. What is the main purpose of the insert operation in a Binary Search Tree (BST)?

easy

A. To find the height of the BST

B. To delete a node from the BST

C. To add a new node while keeping the BST property intact

D. To traverse the BST in order

Solution

1. Step 1: Understand BST property

   A BST keeps nodes ordered so that left child is smaller and right child is larger than the parent.

2. Step 2: Purpose of insert operation

   Insert adds a new node in the correct position to maintain this order.

3. Final Answer:

   To add a new node while keeping the BST property intact -> Option C

4. Quick Check:

   Insert = Add node correctly [OK]

Hint: Insert means add node keeping order [OK]

Common Mistakes:

• Confusing insert with delete operation
• Thinking insert changes tree traversal
• Assuming insert changes tree height always

2. Which of the following is the correct way to declare a BST node structure in C for insertion?

easy

A. typedef struct Node { int data; struct Node* left; struct Node* right; } Node;

B. struct Node { int data; int left; int right; };

C. typedef struct Node { int data; Node left; Node right; } Node;

D. struct Node { int data; struct Node left; struct Node right; };

Solution

1. Step 1: Check pointer usage in struct

   BST nodes must have pointers to left and right child nodes, not direct structs or ints.

2. Step 2: Validate correct syntax

   typedef struct Node { int data; struct Node* left; struct Node* right; } Node; uses pointers to struct Node correctly, others use wrong types or missing pointers.

3. Final Answer:

   typedef struct Node { int data; struct Node* left; struct Node* right; } Node; -> Option A

4. Quick Check:

   Node pointers needed for children [OK]

Hint: Use pointers for left and right child nodes [OK]

Common Mistakes:

• Using int instead of pointers for children
• Missing struct keyword before Node*
• Declaring children as struct instead of pointers

3. Given the following BST and insertion code snippet, what will be the inorder traversal output after inserting 25?

    20
   /  \
 10   30

// Insert function called with root and 25

medium

A. [10, 20, 25, 30]

B. [10, 20, 30, 25]

C. [10, 25, 20, 30]

D. [20, 10, 25, 30]

Solution

1. Step 1: Insert 25 in BST

   25 is greater than 20, so move right to 30. 25 is less than 30, so insert as left child of 30.

2. Step 2: Inorder traversal after insertion

   Inorder visits left, root, right: 10, 20, 25, 30.

3. Final Answer:

   [10, 20, 25, 30] -> Option A

4. Quick Check:

   Inorder sorted = [10, 20, 25, 30] [OK]

Hint: Inorder traversal of BST is sorted list [OK]

Common Mistakes:

• Inserting 25 as right child of 30
• Misordering inorder traversal
• Confusing preorder with inorder

4. Identify the error in the following BST insert function snippet:

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

medium

A. Incorrect comparison operator for val and root->data

B. Missing return statement after creating new node

C. Using malloc instead of calloc

D. Not freeing memory of old nodes

Solution

1. Step 1: Check base case return

   When root is NULL, new node is created but not returned, so function returns garbage.

2. Step 2: Fix missing return

   Must return newNode immediately after creation to link it properly.

3. Final Answer:

   Missing return statement after creating new node -> Option B

4. Quick Check:

   Return new node in base case [OK]

Hint: Always return new node after malloc in base case [OK]

Common Mistakes:

• Forgetting to return new node in base case
• Incorrect pointer assignments
• Ignoring memory allocation errors

5. You have a BST with nodes 15, 10, 20, 8, 12, 17, 25. You want to insert 16. After insertion, what is the preorder traversal of the BST?

hard

A. [15, 10, 8, 12, 20, 17, 25, 16]

B. [15, 10, 8, 12, 20, 16, 17, 25]

C. [15, 10, 8, 12, 20, 25, 17, 16]

D. [15, 10, 8, 12, 20, 17, 16, 25]

Solution

1. Step 1: Insert 16 in BST

   16 is less than 17, so it becomes left child of 17.

2. Step 2: Preorder traversal after insertion

   Preorder visits root, left, right: 15, 10, 8, 12, 20, 17, 16, 25.

3. Final Answer:

   [15, 10, 8, 12, 20, 17, 16, 25] -> Option D

4. Quick Check:

   Preorder = root-left-right [OK]

Hint: Preorder = root, left subtree, then right subtree [OK]

Common Mistakes:

• Inserting 16 as right child of 17
• Mixing preorder with inorder or postorder
• Skipping the new node in traversal