Create a Binary Tree Manually in DSA C - Build from Scratch

Create a Binary Tree Manually

📖 Scenario: You are building a simple binary tree to represent a family tree with three members.

🎯 Goal: Create a binary tree manually by defining nodes and linking them as left and right children.

📋 What You'll Learn

Define a struct called Node with an integer data and two pointers left and right.

Create three nodes with data values 1, 2, and 3.

Link the nodes so that node 1 is the root, node 2 is the left child, and node 3 is the right child.

Print the tree nodes in preorder traversal (root, left, right).

💡 Why This Matters

🌍 Real World

Binary trees are used in many applications like organizing data, searching, and representing hierarchical information such as family trees or file systems.

💼 Career

Understanding how to create and traverse binary trees is fundamental for software developers working with data structures, algorithms, and system design.

1

Define the Node struct and create three nodes

Define a struct called Node with an integer data and two pointers left and right. Then create three variables node1, node2, and node3 of type Node.

DSA C

// Define struct Node and create node1, node2, node3
// Your code here

Hint

Use typedef struct Node to define the node. Create three variables of type Node.

2

Initialize the nodes with data values and set children to NULL

Set node1.data = 1, node2.data = 2, and node3.data = 3. Also set node1.left, node1.right, node2.left, node2.right, node3.left, and node3.right to NULL.

DSA C

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

Node node1;
Node node2;
Node node3;

// Initialize data and set all children to NULL
// Your code here

Hint

Assign the data values directly and set all child pointers to NULL.

3

Link the nodes to form the binary tree

Set node1.left = &node2 and node1.right = &node3 to link node2 as left child and node3 as right child of node1.

DSA C

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

Node node1;
Node node2;
Node node3;

node1.data = 1;
node2.data = 2;
node3.data = 3;

node1.left = NULL;
node1.right = NULL;
node2.left = NULL;
node2.right = NULL;
node3.left = NULL;
node3.right = NULL;

// Link node2 and node3 as children of node1
// Your code here

Hint

Use the address operator & to assign the child nodes.

4

Print the tree nodes in preorder traversal

Write a function void preorder(Node* root) that prints the data of each node in preorder (root, left, right). Then call preorder(&node1) in main.

DSA C

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

Node node1;
Node node2;
Node node3;

node1.data = 1;
node2.data = 2;
node3.data = 3;

node1.left = NULL;
node1.right = NULL;
node2.left = NULL;
node2.right = NULL;
node3.left = NULL;
node3.right = NULL;

node1.left = &node2;
node1.right = &node3;

#include 

// Write preorder function and call it in main
// Your code here

Hint

Use recursion to print the root data, then left subtree, then right subtree. Call preorder(&node1) in main.

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