Validate if Tree is BST in DSA Go

Mental Model

A binary search tree (BST) has nodes arranged so that left children are smaller and right children are bigger than the parent node.

Analogy: Imagine a family tree where every child on the left side is younger than their parent, and every child on the right side is older, keeping the order clear.

      5
     / \
    3   7
   / \   \
  2   4   8

Dry Run Walkthrough

Input: Tree: 5 with left child 3 and right child 7; 3 has children 2 and 4; 7 has right child 8

Goal: Check if this tree follows BST rules where left < parent < right for every node

Step 1: Start at root node 5, set allowed range as (-∞, +∞)

Node=5, range=(-∞, +∞)

Why: We begin with no limits for the root value

Step 2: Check left child 3 with range (-∞, 5)

Node=3, range=(-∞, 5)

Why: Left child must be less than parent 5

Step 3: Check left child 2 with range (-∞, 3)

Node=2, range=(-∞, 3)

Why: Left child of 3 must be less than 3

Step 4: 2 has no children, return true and go back to 3

Node=2 leaf, valid

Why: Leaf nodes are valid by default

Step 5: Check right child 4 of 3 with range (3, 5)

Node=4, range=(3, 5)

Why: Right child of 3 must be greater than 3 and less than 5

Step 6: 4 has no children, return true and go back to 3

Node=4 leaf, valid

Why: Leaf nodes are valid by default

Step 7: Left subtree of 5 is valid, check right child 7 with range (5, +∞)

Node=7, range=(5, +∞)

Why: Right child must be greater than parent 5

Step 8: Check right child 8 of 7 with range (7, +∞)

Node=8, range=(7, +∞)

Why: Right child of 7 must be greater than 7

Step 9: 8 has no children, return true and go back to 7

Node=8 leaf, valid

Why: Leaf nodes are valid by default

Step 10: Right subtree of 5 is valid, whole tree is BST

Tree valid as BST

Why: All nodes satisfy BST conditions

Result:

2 -> 3 -> 4 -> 5 -> 7 -> 8 (inorder traversal) confirms BST

Annotated Code

DSA Go

package main

import (
	"fmt"
	"math"
)

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

func isValidBST(root *TreeNode) bool {
	return validate(root, math.Inf(-1), math.Inf(1))
}

func validate(node *TreeNode, min, max float64) bool {
	if node == nil {
		return true
	}
	val := float64(node.Val)
	if val <= min || val >= max {
		return false
	}
	// Check left subtree with updated max
	if !validate(node.Left, min, val) {
		return false
	}
	// Check right subtree with updated min
	if !validate(node.Right, val, max) {
		return false
	}
	return true
}

func main() {
	root := &TreeNode{Val: 5}
	root.Left = &TreeNode{Val: 3}
	root.Right = &TreeNode{Val: 7}
	root.Left.Left = &TreeNode{Val: 2}
	root.Left.Right = &TreeNode{Val: 4}
	root.Right.Right = &TreeNode{Val: 8}

	fmt.Println(isValidBST(root))
}

return validate(root, math.Inf(-1), math.Inf(1))

start validation with infinite range for root

if node == nil { return true }

empty node is valid BST by definition

if val <= min || val >= max { return false }

check if current node violates min/max range

if !validate(node.Left, min, val) { return false }

validate left subtree with updated max limit

if !validate(node.Right, val, max) { return false }

validate right subtree with updated min limit

Output

true

Complexity Analysis

Time: O(n) because we visit each node once to check BST property

Space: O(h) where h is tree height due to recursion stack

vs Alternative: Compared to inorder traversal checking sorted order, this method checks constraints directly during traversal, saving extra space for storing values

Edge Cases

Empty tree

Returns true because empty tree is a valid BST

DSA Go

if node == nil {
	return true
}

Single node tree

Returns true because single node satisfies BST rules

DSA Go

if node == nil {
	return true
}

Tree with duplicate values

Returns false because BST does not allow duplicates (<= or >= fails)

DSA Go

if val <= min || val >= max {
	return false
}

When to Use This Pattern

When you need to confirm if a binary tree follows the BST rules, use range limits during recursion to validate each node's value fits between allowed min and max.

Common Mistakes

Mistake: Only checking immediate children values without considering entire subtree range
Fix: Pass down min and max limits to ensure all descendants satisfy BST property

Summary

Checks if a binary tree is a valid binary search tree by ensuring all nodes fit within value ranges.

Use when you want to verify the BST property in a binary tree structure.

The key insight is to track allowed min and max values for each node during recursion.

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