Serialize and Deserialize Binary Tree in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the current node is null during serialization.

DSA C#

if (root [1] null) return "#";

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 serialization.

Using comparison operators like '<' or '>' is invalid for null checks.

The code checks if the current node is null to serialize it as "#".

2fill in blank

medium

Complete the code to split the serialized string by commas during deserialization.

DSA C#

var nodes = data.Split([1]);

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

A';'

B':'

C','

D' '

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong separators like ';' or ':' causes incorrect splitting.

Splitting by space ' ' does not match the serialization format.

The serialized nodes are separated by commas, so splitting by ',' gives the list of node values.

3fill in blank

hard

Fix the error in the recursive deserialization call to correctly build the left subtree.

DSA C#

root.Left = DeserializeHelper(nodes, ref [1]);

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

Aindex

Bi

Cpos

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using an undefined variable like 'i' or 'pos' causes errors.

Not passing the index by reference causes incorrect tree building.

The variable 'index' is used to track the current position in the nodes array during deserialization.

4fill in blank

hard

Fill both blanks to correctly convert string to int and advance the index during deserialization.

DSA C#

root.Val = int.Parse(nodes[[1]]); [2]++;

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

Aindex

Bi

Cpos

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variables for access and increment causes errors.

Forgetting to increment the index leads to infinite recursion.

The current index is used to get the node value and then incremented to move forward.

5fill in blank

hard

Fill both blanks to complete the serialization method using preorder traversal.

DSA C#

return root.Val + "," + Serialize(root.[1]) + "," + Serialize(root.[2]);

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

ALeft

BRight

CParent

DChild

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Parent' or 'Child' properties which do not exist.

Mixing the order breaks preorder traversal.

Preorder traversal visits root, then left subtree, then right subtree. The code serializes root.Val, then left, then right.

Practice

1. What is the main purpose of serialize and deserialize methods in the context of a binary tree?

easy

A. Find the height of the binary tree

B. Sort the binary tree nodes in ascending order

C. Delete all nodes from the binary tree

D. Convert a binary tree to a string and back to a binary tree

Solution

1. Step 1: Understand serialization

   Serialization means converting a data structure like a binary tree into a string format that can be stored or transmitted.

2. Step 2: Understand deserialization

   Deserialization means converting the string back into the original binary tree structure.

3. Final Answer:

   Convert a binary tree to a string and back to a binary tree -> Option D

4. Quick Check:

   Serialize/Deserialize = Convert tree to/from string [OK]

Hint: Serialization means tree to string, deserialization reverses it [OK]

Common Mistakes:

• Confusing serialization with sorting
• Thinking serialization deletes nodes
• Assuming serialization finds tree height

2. Which of the following is the correct C# method signature for a serialize method that converts a binary tree root node to a string?

easy

A. public TreeNode Serialize(string data)

B. public void Serialize(TreeNode root)

C. public string Serialize(TreeNode root)

D. public int Serialize(TreeNode root)

Solution

1. Step 1: Identify return type for serialization

   Serialization converts a tree to a string, so the return type must be string.

2. Step 2: Check method parameters

   The method should take the root node of the tree as input, typically TreeNode root.

3. Final Answer:

   public string Serialize(TreeNode root) -> Option C

4. Quick Check:

   Serialize returns string from TreeNode [OK]

Hint: Serialize returns string, input is root node [OK]

Common Mistakes:

• Using void return type for serialize
• Confusing serialize with deserialize signature
• Returning int instead of string

3. Given the following serialized string of a binary tree using preorder with '#' as null marker: "1,2,#,#,3,4,#,#,5,#,#", what is the inorder traversal of the deserialized tree?

medium

A. [5, 4, 3, 2, 1]

B. [2, 1, 4, 3, 5]

C. [2, 4, 1, 3, 5]

D. [1, 2, 3, 4, 5]

Solution

1. Step 1: Reconstruct tree from preorder string

   Preorder: root=1, left subtree=2,#,# (2 with no children), right subtree=3,4,#,#,5,#,# (3 with left=4, right=5).

2. Step 2: Perform inorder traversal (left, root, right)

   Inorder: left subtree of 1 is 2, then root 1, then left subtree of 3 is 4, root 3, right subtree 5. So inorder is [2, 1, 4, 3, 5].

3. Final Answer:

   [2, 1, 4, 3, 5] -> Option B

4. Quick Check:

   Inorder matches reconstructed tree [OK]

Hint: Rebuild tree from preorder, then do inorder traversal [OK]

Common Mistakes:

• Mixing preorder and inorder traversal orders
• Ignoring null markers '#' in deserialization
• Incorrectly assigning left and right children

4. Consider this deserialize method snippet in C#:

public TreeNode Deserialize(string data) {
  var nodes = data.Split(',');
  int index = 0;
  return DeserializeHelper(nodes, ref index);
}

private TreeNode DeserializeHelper(string[] nodes, ref int index) {
  if (index >= nodes.Length || nodes[index] == "#") {
    index++;
    return null;
  }
  TreeNode node = new TreeNode(int.Parse(nodes[index++]));
  node.left = DeserializeHelper(nodes, ref index);
  node.right = DeserializeHelper(nodes, ref index);
  return node;
}

What is the main bug if index was passed without ref keyword?

medium

A. The index will not update correctly across recursive calls, causing infinite recursion or wrong tree

B. The code will not compile due to missing ref keyword

C. The tree will deserialize correctly without any issue

D. The method will throw a NullReferenceException

Solution

1. Step 1: Understand passing index by reference

   Passing index by ref allows recursive calls to update the same variable, tracking position in the array.

2. Step 2: Effect of missing ref

   If index is passed by value, each recursive call gets a copy, so updates won't reflect outside, causing repeated processing of same nodes and infinite recursion or wrong tree.

3. Final Answer:

   The index will not update correctly across recursive calls, causing infinite recursion or wrong tree -> Option A

4. Quick Check:

   Missing ref causes index not to update globally [OK]

Hint: Pass index by ref to track position across recursion [OK]

Common Mistakes:

• Assuming code won't compile without ref
• Thinking tree deserializes correctly without ref
• Confusing NullReferenceException with index issue

5. You want to serialize a binary tree and then deserialize it back. Which approach below correctly handles trees with duplicate values and null nodes?

hard

A. Use preorder traversal with '#' for nulls and commas to separate nodes

B. Use inorder traversal without null markers

C. Use level order traversal but skip null nodes

D. Serialize only leaf nodes and ignore internal nodes

Solution

1. Step 1: Understand serialization requirements

   To handle duplicates and nulls, serialization must record node values and null positions explicitly.

2. Step 2: Evaluate options

   Preorder with '#' for nulls and commas as separators records structure and values including duplicates. Inorder without nulls loses structure. Level order skipping nulls loses position info. Serializing only leaves loses tree shape.

3. Final Answer:

   Use preorder traversal with '#' for nulls and commas to separate nodes -> Option A

4. Quick Check:

   Preorder + null markers preserves full tree [OK]

Hint: Use preorder + null markers to keep duplicates and structure [OK]

Common Mistakes:

• Skipping null nodes loses tree shape
• Using inorder without nulls loses structure
• Ignoring duplicate values in serialization