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

Validate if Tree is BST

📖 Scenario: You are working with a simple family tree where each person has a unique number ID. You want to check if this tree follows the rules of a Binary Search Tree (BST), where the left child has a smaller ID and the right child has a larger ID than the parent.

🎯 Goal: Build a program that creates a binary tree, sets up helper variables, writes the logic to check if the tree is a BST, and finally prints the result.

📋 What You'll Learn

Create a binary tree using a Node class with exact values

Add helper variables to assist in BST validation

Write a function to check if the tree is a BST using recursion

Print True or False depending on the validation result

💡 Why This Matters

🌍 Real World

Binary Search Trees are used in databases and search engines to quickly find data by keeping it sorted.

💼 Career

Understanding BST validation helps in roles like software development and data engineering where tree data structures are common.

1

Create the binary tree nodes

Create a class called Node with an __init__ method that takes val, left, and right parameters. Then create the following nodes exactly: root node with value 10, left child with value 5, and right child with value 15. Connect the left and right children to the root node.

DSA Python

# Define Node class and create root, left, and right nodes
# Your code here

Hint

Define the Node class first, then create the root node with value 10. Add left and right children with values 5 and 15 respectively.

2

Set up helper variables for BST validation

Create two variables called min_val and max_val and set them to float('-inf') and float('inf') respectively. These will help check the valid range for node values during BST validation.

DSA Python

class Node:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

root = Node(10)
root.left = Node(5)
root.right = Node(15)

# Create min_val and max_val variables
# Your code here

Hint

Use Python's float('-inf') and float('inf') to represent the smallest and largest possible values.

3

Write the function to check if the tree is a BST

Define a function called is_bst that takes node, min_val, and max_val as parameters. Use recursion to check if the current node's value is between min_val and max_val. Recursively check the left subtree with updated max value and the right subtree with updated min value. Return True if all nodes satisfy BST conditions, otherwise False. Call is_bst(root, min_val, max_val) and store the result in a variable called result.

DSA Python

class Node:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

root = Node(10)
root.left = Node(5)
root.right = Node(15)

min_val = float('-inf')
max_val = float('inf')

# Define is_bst function and call it with root, min_val, max_val
# Your code here

Hint

Check if the node is None first. Then check if node.val is between min_val and max_val. Recursively check left and right children with updated ranges.

4

Print the result of BST validation

Print the variable result which holds the Boolean value indicating if the tree is a BST.

DSA Python

class Node:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

root = Node(10)
root.left = Node(5)
root.right = Node(15)

min_val = float('-inf')
max_val = float('inf')

def is_bst(node, min_val, max_val):
    if node is None:
        return True
    if not (min_val < node.val < max_val):
        return False
    return is_bst(node.left, min_val, node.val) and is_bst(node.right, node.val, max_val)

result = is_bst(root, min_val, max_val)

# Print the result variable
# Your code here

Hint

Use print(result) to show if the tree is a BST.

Practice

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

easy

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

B. Every node has exactly two children.

C. All nodes have the same value.

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 smaller and all values in the right subtree are larger.

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 this 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: Remember: left < node < right for BST [OK]

Common Mistakes:

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

2. Which of the following Python function signatures is correct to check if a binary tree is a BST?

easy

A. def is_bst(root):

B. def validateBST(root, min_val, max_val):

C. def checkBST(tree):

D. def bst_check():

Solution

1. Step 1: Identify typical BST validation parameters

   To validate BST, we usually pass the node and the allowed min and max value range to check subtree values.

2. Step 2: Match function signatures

   def validateBST(root, min_val, max_val): includes root, min_val, and max_val parameters, which is the standard approach for BST validation.

3. Final Answer:

   def validateBST(root, min_val, max_val): -> Option B

4. Quick Check:

   Function with min and max parameters = def validateBST(root, min_val, max_val): [OK]

Hint: BST check needs min and max limits [OK]

Common Mistakes:

• Using no parameters or wrong parameters
• Missing min and max value checks
• Incorrect function naming causing confusion

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

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def is_bst(node, min_val=float('-inf'), max_val=float('inf')):
    if not node:
        return True
    if not (min_val < node.val < max_val):
        return False
    return (is_bst(node.left, min_val, node.val) and
            is_bst(node.right, node.val, max_val))

root = Node(10)
root.left = Node(5)
root.right = Node(15)
root.left.left = Node(1)
root.left.right = Node(12)
print(is_bst(root))

medium

A. Error

B. True

C. False

D. None

Solution

1. Step 1: Trace the tree structure and BST property

   The node with value 12 is in the left subtree of 10 but greater than 10, violating BST rules.

2. Step 2: Check the is_bst function logic

   The function returns False because 12 is not less than 10 (max_val for left subtree), so the condition fails.

3. Final Answer:

   False -> Option C

4. Quick Check:

   Left subtree value > root = False [OK]

Hint: Check if left subtree values < node [OK]

Common Mistakes:

• Ignoring subtree value ranges
• Assuming all left children are smaller without checking ancestors
• Confusing node values with their immediate parent only

4. Find the bug in the following BST validation function:

def is_bst(node, min_val=None, max_val=None):
    if node is None:
        return True
    if min_val and node.val <= min_val:
        return False
    if max_val and node.val >= max_val:
        return False
    return is_bst(node.left, min_val, node.val) and is_bst(node.right, node.val, max_val)

medium

A. Using 'if min_val' causes incorrect checks when min_val is 0 or negative.

B. The function does not check if node is None.

C. The function should return False when node is None.

D. The recursive calls have wrong parameter order.

Solution

1. Step 1: Analyze condition checks for min_val and max_val

   Using 'if min_val' fails when min_val is 0 or negative because 0 is False in Python.

2. Step 2: Identify correct way to check None

   We should check 'if min_val is not None' to correctly handle 0 or negative values.

3. Final Answer:

   Using 'if min_val' causes incorrect checks when min_val is 0 or negative. -> Option A

4. Quick Check:

   Check None explicitly, not truthiness [OK]

Hint: Use 'is not None' to check min_val and max_val [OK]

Common Mistakes:

• Using truthy checks for numeric bounds
• Ignoring zero or negative values in conditions
• Misordering recursive parameters

5. Given a binary tree where nodes can have duplicate values, which modification to the BST validation logic allows duplicates only on the right subtree?

def is_bst_with_duplicates(node, min_val=float('-inf'), max_val=float('inf')):
    if not node:
        return True
    # Fill condition here
    return (is_bst_with_duplicates(node.left, min_val, node.val) and
            is_bst_with_duplicates(node.right, node.val, max_val))

hard

A. Change condition to: if not (min_val <= node.val < max_val): return False

B. Change condition to: if not (min_val <= node.val <= max_val): return False

C. Change condition to: if not (min_val < node.val < max_val): return False

D. Change condition to: if not (min_val < node.val <= max_val): return False

Solution

1. Step 1: Understand duplicate placement rule

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

2. Step 2: Adjust inequality conditions accordingly

   Left subtree uses min_val <= node.val < max_val, so node.val can be equal to min_val but less than max_val. For right subtree, node.val can be equal to min_val.

3. Final Answer:

   Change condition to: if not (min_val <= node.val < max_val): return False -> Option A

4. Quick Check:

   Duplicates on right: allow equality on right side [OK]

Hint: Allow equality only on right subtree values [OK]

Common Mistakes:

• Allowing duplicates on left subtree
• Using strict inequalities on both sides
• Not adjusting min_val and max_val checks