Create a Binary Tree Manually in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Manual Binary Tree Creation

What is the printed output of this C code that creates a binary tree manually and prints its inorder traversal?

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

void inorder(struct Node* root) {
    if (root != NULL) {
        inorder(root->left);
        printf("%d ", root->data);
        inorder(root->right);
    }
}

int main() {
    struct Node* root = newNode(10);
    root->left = newNode(5);
    root->right = newNode(15);
    root->left->left = newNode(3);
    root->left->right = newNode(7);
    inorder(root);
    return 0;
}

A 10 5 3 7 15

B 15 10 7 5 3

C 3 7 5 10 15

D 3 5 7 10 15

💡 Hint

Inorder traversal prints left subtree, root, then right subtree.

The inorder traversal visits nodes in ascending order for a binary search tree. The tree nodes are 3, 5, 7, 10, 15 arranged so that inorder prints them sorted.

❓ Predict Output

intermediate

Output of Preorder Traversal on Manual Binary Tree

What is the output of the preorder traversal of this manually created binary tree in C?

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

void preorder(struct Node* root) {
    if (root != NULL) {
        printf("%d ", root->data);
        preorder(root->left);
        preorder(root->right);
    }
}

int main() {
    struct Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    preorder(root);
    return 0;
}

A 2 4 5 1 3

B 1 2 4 5 3

C 1 3 2 4 5

D 4 2 5 1 3

💡 Hint

Preorder traversal visits root first, then left subtree, then right subtree.

Preorder traversal prints nodes in the order: root, left subtree, right subtree. The tree structure leads to output 1 2 4 5 3.

🔧 Debug

advanced

Identify the Error in Manual Binary Tree Creation

What error does this C code produce when trying to create a binary tree manually?

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

int main() {
    struct Node* root = newNode(10);
    root->left = newNode(5);
    root->right = newNode(15);
    root->left->left = newNode(3);
    root->left->right = newNode(7);
    printf("%d", root->left->left->data);
    return 0;
}

A Compilation error: missing cast for malloc

B Runtime error: segmentation fault

C No error, prints 3

D Compilation error: missing #include <stdlib.h>

💡 Hint

Casting malloc in C is optional and allowed. The code includes stdlib.h.

The code correctly creates nodes and prints the data 3. Casting malloc is optional in C. The code compiles and runs without error.

🧠 Conceptual

advanced

Number of Nodes in a Manually Created Binary Tree

If you manually create a binary tree in C with root, root->left, root->right, root->left->left, and root->left->right nodes, how many nodes does the tree have?

A 5

B 4

C 3

D 6

💡 Hint

Count each node created explicitly.

The tree has 5 nodes: root, root->left, root->right, root->left->left, and root->left->right.

🚀 Application

expert

Manual Binary Tree Height Calculation

Given this manually created binary tree in C, what is the height of the tree? Height is the number of edges on the longest path from root to a leaf.

DSA C

#include <stdio.h>
#include <stdlib.h>

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

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

int height(struct Node* root) {
    if (root == NULL) return -1;
    int leftHeight = height(root->left);
    int rightHeight = height(root->right);
    return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}

int main() {
    struct Node* root = newNode(20);
    root->left = newNode(10);
    root->right = newNode(30);
    root->left->left = newNode(5);
    root->left->left->left = newNode(2);
    root->right->right = newNode(40);
    printf("%d", height(root));
    return 0;
}

A 3

B 5

C 2

D 4

💡 Hint

Count edges on longest path from root to leaf.

The longest path is from root (20) to 10 to 5 to 2, which has 3 edges, so height is 3.

Practice

1. What is the correct way to manually create a binary tree node in C with value 10?

easy

A. Create a struct node with data = 10 and left, right pointers set to NULL

B. Create an integer variable with value 10

C. Use an array of size 10 to represent the tree

D. Declare a pointer without initializing it

Solution

1. Step 1: Understand binary tree node structure

   A binary tree node in C is usually a struct with data and two pointers (left and right) to child nodes.

2. Step 2: Initialize node with value and NULL children

   To create a node with value 10, set data = 10 and left, right pointers to NULL to indicate no children yet.

3. Final Answer:

   Create a struct node with data = 10 and left, right pointers set to NULL -> Option A

4. Quick Check:

   Binary tree node = struct with data + NULL children [OK]

Hint: Binary tree node = struct with data + NULL children [OK]

Common Mistakes:

• Using an integer variable instead of a struct node
• Not initializing left and right pointers to NULL
• Using arrays to represent nodes directly
• Declaring pointers without allocation or initialization

2. Which of the following is the correct syntax to create a new binary tree node dynamically in C?

easy

A. node newNode = malloc(sizeof(node));

B. struct node newNode = malloc(sizeof(struct node));

C. struct node *newNode = new struct node();

D. struct node *newNode = malloc(sizeof(struct node));

Solution

1. Step 1: Use malloc to allocate memory for a struct pointer

   In C, dynamic memory allocation for a struct pointer uses malloc with sizeof the struct type.

2. Step 2: Correct pointer declaration and malloc usage

   struct node *newNode = malloc(sizeof(struct node)); correctly declares a pointer and assigns malloc result cast implicitly to void*.

3. Final Answer:

   struct node *newNode = malloc(sizeof(struct node)); -> Option D

4. Quick Check:

   Dynamic node creation = pointer + malloc(sizeof(struct node)) [OK]

Hint: Use malloc with sizeof(struct node) for dynamic node creation [OK]

Common Mistakes:

• Declaring struct variable instead of pointer for malloc
• Using C++ style new operator in C
• Missing struct keyword in declaration
• Incorrect type name without struct keyword

3. Given the following code snippet, what is the output when printing root->left->data?

struct node {
  int data;
  struct node *left, *right;
};

struct node *root = malloc(sizeof(struct node));
root->data = 1;
root->left = malloc(sizeof(struct node));
root->left->data = 2;
root->right = NULL;

printf("%d", root->left->data);

medium

A. 0

B. 1

C. 2

D. Segmentation fault

Solution

1. Step 1: Trace node assignments

   root->left is allocated and its data is set to 2.

2. Step 2: Print root->left->data value

   Printing root->left->data outputs 2 as assigned.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   root->left->data = 2 [OK]

Hint: Follow pointer assignments step-by-step to find printed value [OK]

Common Mistakes:

• Confusing root->data with root->left->data
• Assuming uninitialized pointers have zero
• Expecting segmentation fault without null check
• Misreading pointer dereference

4. Identify the error in the following code that tries to create a binary tree node:

struct node {
  int data;
  struct node *left, *right;
};

struct node *root;
root->data = 5;
root->left = NULL;
root->right = NULL;

medium

A. Missing semicolon after struct definition

B. root is not initialized with memory before use

C. Incorrect struct member names

D. root should be an integer, not a pointer

Solution

1. Step 1: Check pointer initialization

   root is declared as a pointer but not assigned memory with malloc or set to a valid node.

2. Step 2: Using root->data without allocation causes error

   Accessing root->data without initialization leads to undefined behavior or crash.

3. Final Answer:

   root is not initialized with memory before use -> Option B

4. Quick Check:

   Pointer must be allocated before dereferencing [OK]

Hint: Always allocate memory before using pointer members [OK]

Common Mistakes:

• Forgetting to allocate memory with malloc
• Assuming pointer is auto-initialized
• Confusing syntax errors with runtime errors
• Misunderstanding pointer vs variable types

5. You want to manually create this binary tree:

    10
   /  \
  5    15
 /    /  \
3    12  20

Which sequence of C statements correctly creates this tree?

hard

A. Create root with 10, root->left with 5, root->right with 15, then root->left->left with 3, root->right->left with 12, root->right->right with 20

B. Create root with 10, root->left with 15, root->right with 5, then root->left->left with 12, root->right->left with 3, root->right->right with 20

C. Create root with 10, root->left with 5, root->right with 15, then root->left->right with 3, root->right->left with 12, root->right->right with 20

D. Create root with 10, root->left with 5, root->right with 15, then root->left->left with 12, root->right->left with 3, root->right->right with 20

Solution

1. Step 1: Map tree structure to pointers

   Root is 10, left child 5, right child 15. Left child of 5 is 3. Left and right children of 15 are 12 and 20 respectively.

2. Step 2: Verify pointer assignments match tree

   Create root with 10, root->left with 5, root->right with 15, then root->left->left with 3, root->right->left with 12, root->right->right with 20 correctly assigns left and right pointers to match the tree shape and values.

3. Final Answer:

   Create root with 10, root->left with 5, root->right with 15, then root->left->left with 3, root->right->left with 12, root->right->right with 20 -> Option A

4. Quick Check:

   Pointer assignments match tree structure [OK]

Hint: Match tree diagram nodes to left/right pointers carefully [OK]

Common Mistakes:

• Swapping left and right children
• Assigning nodes to wrong child pointers
• Missing some child node assignments
• Confusing node values with pointer positions