Binary Tree Node Structure in DSA Go - Build from Scratch

Binary Tree Node Structure

📖 Scenario: Imagine you are building a simple family tree app. Each person can have up to two children. You want to create the basic structure to hold each person and their children.

🎯 Goal: Create a binary tree node structure in Go to represent a person and their two children.

📋 What You'll Learn

Define a struct called TreeNode with an integer field Value

Add two pointer fields Left and Right of type *TreeNode

Create a root node with value 10

Assign left child with value 5 and right child with value 15

Print the root node's value and its children's values

💡 Why This Matters

🌍 Real World

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

💼 Career

Understanding how to create and manipulate tree structures is important for software development roles involving data organization, algorithms, and system design.

1

Define the TreeNode struct

Define a struct called TreeNode with an integer field Value and two pointer fields Left and Right of type *TreeNode.

DSA Go

// Define the TreeNode struct here
// Your code here

Hint

Use type TreeNode struct {} to define the structure. Inside, add Value int, Left *TreeNode, and Right *TreeNode.

2

Create the root node and children

Inside main, create a variable root of type *TreeNode with Value 10. Then assign its Left child with a TreeNode of Value 5 and its Right child with a TreeNode of Value 15.

DSA Go

package main

type TreeNode struct {
    Value int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    // Create root node with Value 10
    // Assign Left child with Value 5
    // Assign Right child with Value 15
    // Your code here
}

Hint

Use &TreeNode{Value: 10} to create a pointer to a new node. Assign children similarly.

3

Add a helper variable for printing

Create a variable called nodes as a slice of pointers to TreeNode containing root, root.Left, and root.Right.

DSA Go

package main

type TreeNode struct {
    Value int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Value: 10}
    root.Left = &TreeNode{Value: 5}
    root.Right = &TreeNode{Value: 15}
    // Create nodes slice with root, root.Left, root.Right
    // Your code here
}

Hint

Use a slice literal like nodes := []*TreeNode{root, root.Left, root.Right}.

4

Print the values of root and its children

Use a for loop with variable node to iterate over nodes and print each node's Value using fmt.Println(node.Value). Import fmt package at the top.

DSA Go

package main

import "fmt"

type TreeNode struct {
    Value int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Value: 10}
    root.Left = &TreeNode{Value: 5}
    root.Right = &TreeNode{Value: 15}
    nodes := []*TreeNode{root, root.Left, root.Right}
    // Print each node's Value
    // Your code here
}

Hint

Use for _, node := range nodes and inside the loop fmt.Println(node.Value).

Practice

1. What is the correct way to define a node structure for a binary tree in Go?

easy

A. type Node struct { Value int; Left Node; Right Node }

B. type Node struct { Value int; Left *Node; Right *Node }

C. type Node struct { Value int; Left int; Right int }

D. type Node struct { Value *int; Left *int; Right *int }

Solution

1. Step 1: Understand binary tree node components

   A binary tree node stores a value and pointers to left and right child nodes.

2. Step 2: Check pointer usage in Go struct

   Using pointers (*Node) for Left and Right allows linking nodes without copying entire structs.

3. Final Answer:

   type Node struct { Value int; Left *Node; Right *Node } -> Option B

4. Quick Check:

   Node with pointers = type Node struct { Value int; Left *Node; Right *Node } [OK]

Hint: Use pointers for child nodes to avoid copying structs [OK]

Common Mistakes:

• Using non-pointer types for child nodes causes infinite recursion
• Using int instead of *Node for children
• Using pointers to int instead of pointers to Node

2. Which of the following is the correct syntax to create a new binary tree node with value 10 in Go?

easy

A. node := Node{Value: 10, Left: nil, Right: nil}

B. node := Node(10, nil, nil)

C. node := &Node{Value: 10, Left: nil, Right: nil}

D. node := new(Node{10, nil, nil})

Solution

1. Step 1: Understand node creation with pointers

   To create a pointer to a Node struct, use &Node{...} syntax.

2. Step 2: Check each option's syntax

   node := &Node{Value: 10, Left: nil, Right: nil} correctly creates a pointer to a Node with value 10 and nil children.

3. Final Answer:

   node := &Node{Value: 10, Left: nil, Right: nil} -> Option C

4. Quick Check:

   Pointer node creation uses &Node{...} [OK]

Hint: Use &Node{...} to create pointer nodes [OK]

Common Mistakes:

• Forgetting & to create pointer
• Using new() incorrectly with struct literals
• Calling Node() like a function

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

package main
import "fmt"

type Node struct {
  Value int
  Left  *Node
  Right *Node
}

func main() {
  root := &Node{Value: 1}
  root.Left = &Node{Value: 2}
  root.Right = &Node{Value: 3}
  fmt.Println(root.Left.Value)
}

medium

A. 2

B. 1

C. 3

D. Compilation error

Solution

1. Step 1: Analyze node assignments

   root.Left is assigned a node with Value 2, root.Right with Value 3, root.Value is 1.

2. Step 2: Check printed value

   fmt.Println(root.Left.Value) prints the Value of the left child node, which is 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   root.Left.Value = 2 [OK]

Hint: Print child node's Value to get assigned integer [OK]

Common Mistakes:

• Printing root.Value instead of root.Left.Value
• Confusing left and right child values
• Expecting compilation error due to missing import

4. Identify the error in the following Go code defining a binary tree node:

type Node struct {
  Value int
  Left Node
  Right *Node
}

func main() {
  root := &Node{Value: 5}
  root.Left = Node{Value: 3}
}

medium

A. Left child should be a pointer to Node, not Node value

B. Right child should not be a pointer

C. Value field must be a pointer to int

D. Cannot assign struct literal to Left field

Solution

1. Step 1: Check struct field types

   Left is declared as Node (value), Right as *Node (pointer). This causes recursive struct size issues.

2. Step 2: Understand pointer necessity

   Binary tree nodes must use pointers for children to avoid infinite size and allow nil values.

3. Final Answer:

   Left child should be a pointer to Node, not Node value -> Option A

4. Quick Check:

   Child nodes must be pointers [OK]

Hint: Use *Node for all child fields to avoid infinite struct size [OK]

Common Mistakes:

• Mixing pointer and value types for children
• Expecting Go to allow recursive value fields
• Ignoring nil possibility for children

5. Given the binary tree node structure below, how would you write a function in Go to insert a new value into a binary search tree?

type Node struct {
  Value int
  Left  *Node
  Right *Node
}

Choose the correct approach.

hard

A. Insert new value at root and push existing nodes down

B. Always insert new value as left child without comparison

C. Use a loop to find nil child and insert without comparison

D. Recursively compare new value with current node; insert left if smaller, right if larger; create new node if nil child

Solution

1. Step 1: Understand binary search tree insertion logic

   New values less than current node go to left subtree; greater go to right subtree.

2. Step 2: Use recursion to find correct insertion point

   Recursively traverse left or right child until a nil child is found, then insert new node there.

3. Final Answer:

   Recursively compare new value with current node; insert left if smaller, right if larger; create new node if nil child -> Option D

4. Quick Check:

   BST insertion uses recursive comparison [OK]

Hint: Compare and recurse left/right until nil, then insert [OK]

Common Mistakes:

• Inserting without comparison breaks BST property
• Always inserting on one side causes imbalance
• Not handling nil child case properly