Validate if Tree is BST in DSA Go - Build from Scratch

Validate if Tree is BST

📖 Scenario: Imagine you have a family tree where each person has a unique number. You want to check if this tree follows special rules so that it is a Binary Search Tree (BST). In a BST, every left child has a smaller number than its parent, and every right child has a bigger number than its parent.

🎯 Goal: You will build a simple program in Go to check if a given tree is a BST or not. This helps in many computer tasks like searching quickly.

📋 What You'll Learn

Create a tree node structure called Node with value, left, and right fields

Create a sample tree with exact values and structure

Write a function isBST that checks if the tree is a BST

Print true or false based on the check

💡 Why This Matters

🌍 Real World

Checking if a tree is a BST is important in databases and search engines to keep data organized for fast searching.

💼 Career

Software developers and data engineers often need to verify tree structures for correctness and efficiency.

1

Create the Tree Node Structure and Sample Tree

Create a struct called Node with an int field value and two pointers to Node called left and right. Then create a variable root which is a pointer to Node representing this tree:

10
/ \
5 15
/ \ \
2 7 20

DSA Go

// Define Node struct and create root node with children
// Your code here

Hint

Use type Node struct to define the tree node. Use &Node{value: X} to create nodes and link them.

2

Add Helper Function Parameters for Limits

Create two variables min and max of type int in the main function. Set min to -1 << 31 (minimum int) and max to 1<<31 - 1 (maximum int). These will help check if values are in the correct range.

DSA Go

package main

type Node struct {
    value int
    left  *Node
    right *Node
}

func main() {
    root := &Node{value: 10}
    root.left = &Node{value: 5}
    root.right = &Node{value: 15}
    root.left.left = &Node{value: 2}
    root.left.right = &Node{value: 7}
    root.right.right = &Node{value: 20}

    // Create min and max int variables
    // Your code here
}

Hint

Use bit shifting to get minimum and maximum 32-bit integer values.

3

Write the isBST Function

Write a function isBST that takes a pointer to Node, and two int parameters min and max. It returns bool. The function should:
- Return true if the node is nil.
- Return false if the node's value is not between min and max.
- Recursively check the left subtree with updated max as node.value - 1.
- Recursively check the right subtree with updated min as node.value + 1.
- Return true only if both subtrees are BSTs.

DSA Go

package main

type Node struct {
    value int
    left  *Node
    right *Node
}

func isBST(node *Node, min int, max int) bool {
    // Your code here
}

func main() {
    root := &Node{value: 10}
    root.left = &Node{value: 5}
    root.right = &Node{value: 15}
    root.left.left = &Node{value: 2}
    root.left.right = &Node{value: 7}
    root.right.right = &Node{value: 20}

    min := -1 << 31
    max := 1<<31 - 1
}

Hint

Check for nil node first. Then check if value is out of range. Use recursion for left and right subtrees with updated limits.

4

Print the Result of isBST Check

In the main function, call isBST with root, min, and max. Print the returned boolean value.

DSA Go

package main

type Node struct {
    value int
    left  *Node
    right *Node
}

func isBST(node *Node, min int, max int) bool {
    if node == nil {
        return true
    }
    if node.value  max {
        return false
    }
    return isBST(node.left, min, node.value-1) && isBST(node.right, node.value+1, max)
}

func main() {
    root := &Node{value: 10}
    root.left = &Node{value: 5}
    root.right = &Node{value: 15}
    root.left.left = &Node{value: 2}
    root.left.right = &Node{value: 7}
    root.right.right = &Node{value: 20}

    min := -1 << 31
    max := 1<<31 - 1

    // Print the result of isBST
    // Your code here
}

Hint

Use println(isBST(root, min, max)) to print the result.

Practice

1. What does it mean for a binary tree to be a Binary Search Tree (BST)?

easy

A. All nodes have the same value.

B. Every node has exactly two children.

C. The tree is balanced with equal height on both sides.

D. Every node's left subtree contains values less than the node, and right subtree contains values greater.

Solution

1. Step 1: Understand BST property

   A BST requires that for each node, all values in the left subtree are less than the node's value, and all values in the right subtree are greater.

2. Step 2: Compare options with definition

   Every node's left subtree contains values less than the node, and right subtree contains values greater. matches the BST property exactly, while others describe different tree properties.

3. Final Answer:

   Every node's left subtree contains values less than the node, and right subtree contains values greater. -> Option D

4. Quick Check:

   BST property = Every node's left subtree contains values less than the node, and right subtree contains values greater. [OK]

Hint: BST means left < node < right for every node [OK]

Common Mistakes:

• Confusing BST with balanced tree
• Thinking all nodes must have two children
• Assuming all values are equal

2. Which Go function signature correctly represents a function to check if a binary tree is a BST?

easy

A. func isBST(root *Node) bool

B. func isBST(root Node) int

C. func checkBST(root *Node) string

D. func validateBST(root Node) void

Solution

1. Step 1: Identify correct parameter and return types

   The function should accept a pointer to the root node (to avoid copying) and return a boolean indicating if the tree is BST.

2. Step 2: Match with options

   func isBST(root *Node) bool matches this: it takes *Node and returns bool. Others have wrong parameter types or return types.

3. Final Answer:

   func isBST(root *Node) bool -> Option A

4. Quick Check:

   Pointer input + bool output = func isBST(root *Node) bool [OK]

Hint: Use pointer receiver and bool return for BST check [OK]

Common Mistakes:

• Passing Node by value instead of pointer
• Returning int or string instead of bool
• Using void (no return) for validation function

3. Given the following Go code, what will be the output?

package main

import "fmt"

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

func isBSTUtil(node *Node, min, max int) bool {
    if node == nil {
        return true
    }
    if node.Val <= min || node.Val >= max {
        return false
    }
    return isBSTUtil(node.Left, min, node.Val) && isBSTUtil(node.Right, node.Val, max)
}

func isBST(root *Node) bool {
    return isBSTUtil(root, -1000, 1000)
}

func main() {
    root := &Node{Val: 10}
    root.Left = &Node{Val: 5}
    root.Right = &Node{Val: 15}
    root.Right.Left = &Node{Val: 6}
    root.Right.Right = &Node{Val: 20}
    fmt.Println(isBST(root))
}

medium

A. false

B. true

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Trace tree values against BST rules

   The node with value 6 is in the right subtree of 10 but less than 10, violating BST property.

2. Step 2: Check isBSTUtil logic

   isBSTUtil checks if node.Val is within (min, max). For node 6, min=10, max=15, but 6 <= 10 fails the condition, returning false.

3. Final Answer:

   false -> Option A

4. Quick Check:

   6 in right subtree < 10 = false [OK]

Hint: Check subtree values against min/max bounds [OK]

Common Mistakes:

• Ignoring subtree value constraints
• Assuming all nodes in right subtree are greater than root only
• Not updating min/max bounds during recursion

4. The following Go function is intended to check if a binary tree is a BST, but it has a bug. What is the bug?

func isBST(node *Node) bool {
    if node == nil {
        return true
    }
    if node.Left != nil && node.Left.Val > node.Val {
        return false
    }
    if node.Right != nil && node.Right.Val < node.Val {
        return false
    }
    return isBST(node.Left) && isBST(node.Right)
}

medium

A. It does not handle nil nodes correctly.

B. It only compares immediate children, missing deeper subtree violations.

C. It uses wrong comparison operators for BST.

D. It causes infinite recursion.

Solution

1. Step 1: Analyze comparison logic

   The function compares only node.Left.Val and node.Right.Val with node.Val, ignoring entire subtree values.

2. Step 2: Understand BST violation cases

   A violation can occur deeper in subtrees, e.g., a left subtree node greater than root, which this function misses.

3. Final Answer:

   It only compares immediate children, missing deeper subtree violations. -> Option B

4. Quick Check:

   Check all subtree nodes, not just immediate children [OK]

Hint: Check entire subtree ranges, not just direct children [OK]

Common Mistakes:

• Checking only immediate children values
• Not passing min/max bounds in recursion
• Assuming local checks guarantee global BST

5. You want to validate if a binary tree is a BST but the tree nodes can have duplicate values. Which modification to the standard BST validation logic is correct to allow duplicates only on the right subtree?

hard

A. Change the condition to allow node.Val <= max for left subtree and node.Val > max for right subtree.

B. Allow duplicates only if node.Val >= min for left subtree and node.Val < max for right subtree.

C. Allow duplicates only if node.Val > min for left subtree and node.Val <= max for right subtree.

D. Allow duplicates on both sides without changing conditions.

Solution

1. Step 1: Understand duplicate placement in BST

   Duplicates allowed only on right means left subtree nodes must be strictly less than node.Val, right subtree nodes can be equal or greater.

2. Step 2: Adjust min/max conditions accordingly

   Change violation check to (node.Val <= min || node.Val > max), enforcing node.Val > min && node.Val <= max. This allows equality to max (parent.Val in right calls) but enforces > min (parent.Val in left calls).

3. Final Answer:

   Allow duplicates only if node.Val > min for left subtree and node.Val <= max for right subtree. -> Option C

4. Quick Check:

   > min && <= max = duplicates on right only [OK]

Hint: Use > min && <= max to allow duplicates on right [OK]

Common Mistakes:

• Allowing duplicates on left subtree
• Not adjusting inequality signs properly
• Allowing duplicates on both sides without rules