Binary Tree Node Structure in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a binary tree node?

A binary tree node is a basic unit of a binary tree that contains data and two pointers or references: one to the left child and one to the right child.

beginner

What are the main components of a binary tree node in C++?

The main components are:
1. Data (value stored in the node)
2. Pointer to the left child node
3. Pointer to the right child node

beginner

Show a simple C++ struct definition for a binary tree node.

struct Node {
int data;
Node* left;
Node* right;
Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

beginner

Why do we initialize left and right pointers to nullptr in a binary tree node?

We initialize left and right pointers to nullptr to indicate that the node does not have children yet. It helps avoid undefined behavior when accessing child nodes.

beginner

Can a binary tree node have only one child? Explain.

Yes, a binary tree node can have zero, one, or two children. If it has only one child, either the left or right pointer will point to a child node, and the other will be nullptr.

What does a binary tree node typically contain?

A Data and two child pointers

B Only data

C Data and three child pointers

D Only two child pointers

A binary tree node contains data and two pointers: one to the left child and one to the right child.

In C++, what keyword is used to indicate a pointer that points to no object?

A nullptr

B void

C null

D zero

nullptr is the keyword in modern C++ to indicate a pointer that points to no object.

If a binary tree node has no children, what are its left and right pointers set to?

A Point to itself

B Point to root

C nullptr

D Undefined

Left and right pointers are set to nullptr to show no children.

How many children can a binary tree node have at most?

A Unlimited

B One

C Three

D Two

A binary tree node can have at most two children: left and right.

Which of these is a correct way to define a binary tree node constructor in C++?

A Node(int val) { data = val; left = right = 0; }

B Node(int val) { data = val; left = right = nullptr; }

C Node(int val) { data = val; left = right = NULL; }

D Node(int val) { data = val; left = right = val; }

Setting left and right to nullptr is the modern and correct way to initialize pointers to no child.

Describe the structure of a binary tree node and its components.

Think about what each node stores and how it connects to children.

Explain why initializing child pointers to nullptr is important in a binary tree node.

Consider what happens if pointers are not initialized.

Practice

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

easy

A. A data value and pointers to left and right child nodes

B. Only a data value without any pointers

C. Pointers to parent and sibling nodes only

D. A data value and a pointer to the next node in a list

Solution

1. Step 1: Understand binary tree node components

   A binary tree node stores a data value and has two pointers: one to the left child and one to the right child.

2. Step 2: Compare options with definition

   A data value and pointers to left and right child nodes correctly describes this structure. Other options miss pointers or mention unrelated pointers.

3. Final Answer:

   A data value and pointers to left and right child nodes -> Option A

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 only one pointer
• Confusing with linked list node structure
• Assuming parent pointer is always present

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

easy

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

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

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

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

Solution

1. Step 1: Check pointer syntax in struct

   In C++, pointers are declared with '*', so left and right children must be pointers: Node* left; Node* right;

2. Step 2: Validate each option

   struct Node { int data; Node* left; Node* right; }; uses correct pointer syntax. struct Node { int data; Node left; Node right; }; uses objects (causes infinite recursion). struct Node { int data; Node& left; Node& right; }; uses references incorrectly. struct Node { int data; Node left*; Node right*; }; has invalid pointer syntax.

3. Final Answer:

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

4. Quick Check:

   Pointer syntax = Node* left/right [OK]

Hint: Pointers use * after type, not before variable name [OK]

Common Mistakes:

• Using objects instead of pointers for children
• Using references (&) for child nodes
• Incorrect pointer syntax like 'left*'

3. What will be the output of the following code snippet?

struct Node {
  int data;
  Node* left;
  Node* right;
  Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

int main() {
  Node* root = new Node(10);
  root->left = new Node(5);
  root->right = new Node(15);
  std::cout << root->left->data << " " << root->right->data << std::endl;
  return 0;
}

medium

A. Compilation error

B. 5 15

C. 5 10

D. 10 15

Solution

1. Step 1: Understand node creation and assignments

   Root node has data 10. Left child is assigned a node with data 5. Right child is assigned a node with data 15.

2. Step 2: Trace the output statement

   Output prints root->left->data (5) and root->right->data (15) separated by space.

3. Final Answer:

   5 15 -> Option B

4. Quick Check:

   Left child = 5, Right child = 15 [OK]

Hint: Follow pointer assignments to print child node data [OK]

Common Mistakes:

• Printing root data instead of children
• Confusing left and right child values
• Forgetting to initialize children

4. Identify the error in the following binary tree node struct and fix it:

struct Node {
  int data;
  Node left;
  Node right;
  Node(int val) : data(val) {}
};

medium

A. Remove constructor and use public members only

B. Add default constructor to initialize data

C. Change 'int data;' to 'int* data;'

D. Change 'Node left;' and 'Node right;' to 'Node* left;' and 'Node* right;'

Solution

1. Step 1: Identify the problem with member declarations

   Declaring 'Node left;' and 'Node right;' causes infinite recursion because each Node contains two Nodes inside it.

2. Step 2: Fix by using pointers for children

   Change to 'Node* left;' and 'Node* right;' to hold addresses of child nodes, avoiding infinite size.

3. Final Answer:

   Change 'Node left;' and 'Node right;' to 'Node* left;' and 'Node* right;' -> Option D

4. Quick Check:

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

Hint: Child nodes must be pointers, not objects [OK]

Common Mistakes:

• Using objects for children causing infinite size
• Ignoring pointer usage in tree nodes
• Trying to fix with constructors only

5. You want to create a binary tree node struct that also stores a pointer to its parent node. Which of the following is the correct way to define it?

hard

A. struct Node { int data; Node left; Node right; Node parent; Node(int val) : data(val) {} };

B. struct Node { int data; Node* left; Node* right; int* parent; Node(int val) : data(val), left(nullptr), right(nullptr), parent(nullptr) {} };

C. struct Node { int data; Node* left; Node* right; Node* parent; Node(int val) : data(val), left(nullptr), right(nullptr), parent(nullptr) {} };

D. struct Node { int data; Node* left; Node* right; Node& parent; Node(int val) : data(val), left(nullptr), right(nullptr), parent(*this) {} };

Solution

1. Step 1: Understand parent pointer type

   The parent pointer must be of type 'Node*' to point to another node or nullptr if no parent.

2. Step 2: Check constructor initialization

   Constructor initializes data and sets left, right, and parent pointers to nullptr correctly.

3. Step 3: Validate options

   struct Node { int data; Node* left; Node* right; Node* parent; Node(int val) : data(val), left(nullptr), right(nullptr), parent(nullptr) {} }; correctly uses pointers for children and parent. struct Node { int data; Node left; Node right; Node parent; Node(int val) : data(val) {} }; uses objects causing recursion. struct Node { int data; Node* left; Node* right; int* parent; Node(int val) : data(val), left(nullptr), right(nullptr), parent(nullptr) {} }; wrongly uses 'int*' for parent. struct Node { int data; Node* left; Node* right; Node& parent; Node(int val) : data(val), left(nullptr), right(nullptr), parent(*this) {} }; uses reference incorrectly and initializes parent to self.

4. Final Answer:

   struct Node { int data; Node* left; Node* right; Node* parent; Node(int val) : data(val), left(nullptr), right(nullptr), parent(nullptr) {} }; -> Option C

5. Quick Check:

   Parent pointer = Node* parent [OK]

Hint: Parent pointer must be Node* and initialized to nullptr [OK]

Common Mistakes:

• Using object or reference for parent pointer
• Incorrect pointer type for parent
• Initializing parent pointer incorrectly