Binary Tree Node Structure in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a pointer to the left child node.

DSA C

struct Node {
    int data;
    struct Node* [1];
    struct Node* right;
};

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

Aprev

Bchild

Cnext

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'child' or 'next' which are not standard names for binary tree pointers.

The left child pointer in a binary tree node is conventionally named 'left'.

2fill in blank

medium

Complete the code to define a function that creates a new node with given data.

DSA C

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

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

Aright

Bnext

Cchild

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect pointer names like 'child' or 'parent'.

The right child pointer must be initialized to NULL when creating a new node.

3fill in blank

hard

Fix the error in the code to correctly assign the left child of a node.

DSA C

void setLeftChild(struct Node* parent, struct Node* child) {
    parent->[1] = child;
}

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

Achild

Bright

Cleft

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning to 'right' or 'child' which are incorrect pointer names.

To assign the left child, use the 'left' pointer of the parent node.

4fill in blank

hard

Fill both blanks to declare a binary tree node struct with data and child pointers.

DSA C

struct Node {
    [1] data;
    struct Node* [2];
    struct Node* right;
};

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

Aint

Bfloat

Cleft

Dchar

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong data types like 'float' or 'char' when integer is expected.

Using incorrect pointer names like 'right' for the left child.

The data is an integer and the left child pointer is named 'left'.

5fill in blank

hard

Fill all three blanks to complete the function that initializes a new node with data and NULL children.

DSA C

struct Node* createNode([1] data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->[2] = NULL;
    newNode->[3] = NULL;
    return newNode;
}

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

Aint

Bleft

Cright

Dfloat

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong data types like 'float'.

Mixing up left and right pointer names.

The function takes an int data, and initializes left and right pointers to NULL.

Practice

1. What does a typical binary tree node structure contain in C?

easy

A. Two data fields and no pointers

B. Only a data field without any pointers

C. A data field and a pointer to the parent node only

D. A data field and two pointers to left and right child nodes

Solution

1. Step 1: Understand binary tree node components

   A binary tree node must hold data and links to its children to form the tree structure.

2. Step 2: Identify correct structure

   The node typically has one data field and two pointers: one for the left child and one for the right child.

3. Final Answer:

   A data field and two pointers to left and right child nodes -> Option D

4. Quick Check:

   Binary tree node = data + left + right pointers [OK]

Hint: Remember: binary tree nodes have two child pointers [OK]

Common Mistakes:

• Thinking nodes have no pointers
• Confusing parent pointer with child pointers
• Assuming multiple data fields

2. Which of the following is the correct C syntax to define a binary tree node structure?

easy

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

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

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

D. struct Node { int data; struct Node* parent; };

Solution

1. Step 1: Check pointer usage in struct

   In C, pointers to the same struct type must be declared with 'struct Node*' inside the struct.

2. Step 2: Identify correct syntax

   struct Node { int data; struct Node* left; struct Node* right; }; correctly uses 'struct Node*' for left and right child pointers.

3. Final Answer:

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

4. Quick Check:

   Use 'struct Node*' for pointers inside struct [OK]

Hint: Use 'struct Node*' for pointers inside struct in C [OK]

Common Mistakes:

• Omitting 'struct' keyword before Node*
• Using struct Node instead of pointer causing infinite size
• Confusing parent pointer with child pointers

3. Given the following code, what will be printed?

struct Node {
  int data;
  struct Node* left;
  struct Node* right;
};

int main() {
  struct Node n1 = {10, NULL, NULL};
  struct Node n2 = {20, NULL, NULL};
  struct Node root = {5, &n1, &n2};
  printf("%d %d %d", root.data, root.left->data, root.right->data);
  return 0;
}

medium

A. 5 10 20

B. 10 5 20

C. 5 0 0

D. Compilation error

Solution

1. Step 1: Understand node initialization

   n1 has data 10, n2 has data 20, root has data 5 with left pointing to n1 and right pointing to n2.

2. Step 2: Trace printf output

   root.data is 5, root.left->data is 10, root.right->data is 20, so output is '5 10 20'.

3. Final Answer:

   5 10 20 -> Option A

4. Quick Check:

   Print root and children data = 5 10 20 [OK]

Hint: Follow pointers to child nodes for data [OK]

Common Mistakes:

• Confusing data values of nodes
• Assuming NULL pointers print zero
• Mixing order of print arguments

4. Identify the error in this binary tree node definition:

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

medium

A. Left and right should be pointers, not structs

B. Missing semicolon after struct definition

C. Data field should be a pointer

D. Struct name should be lowercase

Solution

1. Step 1: Analyze struct member types

   Left and right are declared as struct Node, which causes infinite size because each contains two more structs recursively.

2. Step 2: Correct pointer usage

   They should be pointers (struct Node*) to avoid infinite recursion and allow linking nodes.

3. Final Answer:

   Left and right should be pointers, not structs -> Option A

4. Quick Check:

   Child nodes must be pointers to avoid infinite size [OK]

Hint: Use pointers for child nodes to prevent infinite size [OK]

Common Mistakes:

• Declaring child nodes as structs instead of pointers
• Ignoring compiler errors about struct size
• Thinking data field needs to be pointer

5. You want to create a binary tree node in C that stores a character and has pointers to left and right children. Which of the following struct definitions correctly achieves this and allows dynamic node creation?

hard

A. struct Node { char data; struct Node left; struct Node right; }; struct Node* createNode(char c) { struct Node newNode; newNode.data = c; newNode.left = NULL; newNode.right = NULL; return &newNode; }

B. struct Node { char data; struct Node* left; struct Node* right; }; struct Node* createNode(char c) { struct Node* newNode = malloc(sizeof(struct Node)); newNode->data = c; newNode->left = NULL; newNode->right = NULL; return newNode; }

C. struct Node { char data; struct Node* left; struct Node* right; }; struct Node createNode(char c) { struct Node newNode; newNode.data = c; newNode.left = NULL; newNode.right = NULL; return newNode; }

D. struct Node { char data; struct Node* left; struct Node* right; }; struct Node* createNode(char c) { struct Node newNode; newNode.data = c; newNode.left = NULL; newNode.right = NULL; return newNode; }

Solution

1. Step 1: Check struct definition

   struct Node { char data; struct Node* left; struct Node* right; }; struct Node* createNode(char c) { struct Node* newNode = malloc(sizeof(struct Node)); newNode->data = c; newNode->left = NULL; newNode->right = NULL; return newNode; } correctly defines pointers for left and right children and uses char data type.

2. Step 2: Verify dynamic node creation

   struct Node { char data; struct Node* left; struct Node* right; }; struct Node* createNode(char c) { struct Node* newNode = malloc(sizeof(struct Node)); newNode->data = c; newNode->left = NULL; newNode->right = NULL; return newNode; } uses malloc to allocate memory dynamically and initializes pointers to NULL, returning a pointer to the new node.

3. Final Answer:

   Correct struct with pointers and dynamic allocation using malloc -> Option B

4. Quick Check:

   Dynamic node creation requires malloc and pointer returns [OK]

Hint: Use malloc and pointers for dynamic binary tree nodes [OK]

Common Mistakes:

• Returning address of local variable (invalid after function ends)
• Using struct members instead of pointers for children
• Not initializing child pointers to NULL