Validate if Tree is BST in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the current node is nil.

DSA Go

if [1] == nil {
    return true
}

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

Anode

Broot

Ctree

DrootNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'root' instead of 'node' causes confusion in recursion.

Checking for 'tree' or 'rootNode' which are not defined in this scope.

We check if the current node (named 'node') is nil to stop recursion.

2fill in blank

medium

Complete the code to check if the current node's value is within the allowed range.

DSA Go

if node.Val <= [1] || node.Val >= [2] {
    return false
}

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

Amin

Bmax

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'left' or 'right' instead of min and max confuses the range check.

Using >= for min or <= for max reverses the logic.

The node's value must be greater than min and less than max to be valid in BST.

3fill in blank

hard

Fix the error in the recursive call to validate the left subtree with updated max boundary.

DSA Go

return isValidBSTHelper(node.Left, [1], node.Val) && isValidBSTHelper(node.Right, node.Val, [2])

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

Amin

Bnode.Val

Cmax

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping min and max in recursive calls.

Passing nil instead of boundaries causes runtime errors.

For the left subtree, max becomes node.Val; for the right subtree, min becomes node.Val.

4fill in blank

hard

Fill both blanks to initialize the min and max values for the first call to isValidBST.

DSA Go

func isValidBST(root *TreeNode) bool {
    return isValidBSTHelper(root, [1], [2])
}

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

Amath.MinInt64

Bmath.MaxInt64

C0

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 for boundaries restricts valid values incorrectly.

Using nil causes type errors in Go.

We start with the smallest and largest possible integer values as boundaries.

5fill in blank

hard

Fill all three blanks to complete the helper function signature and recursive calls correctly.

DSA Go

func isValidBSTHelper(node *TreeNode, [1] int64, [2] int64) bool {
    if node == nil {
        return true
    }
    if node.Val <= [1] || node.Val >= [2] {
        return false
    }
    return isValidBSTHelper(node.Left, [1], node.Val) && isValidBSTHelper(node.Right, node.Val, [2])
}

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

Amin

Bmax

Cval

DnodeVal

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent parameter names causes confusion.

Passing wrong variables in recursive calls.

The helper takes min and max as int64 boundaries; node.Val is checked against min and max.

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