Validate if Tree is BST in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA Python

def is_bst(node):
    if node is [1]:
        return True

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

AFalse

BTrue

C0

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of None

Returning False for empty nodes

The base case for recursion is when the node is None, meaning an empty subtree, which is a valid BST.

2fill in blank

medium

Complete the code to check if the left child value is less than the current node's value.

DSA Python

def is_bst(node):
    if node.left and node.left.val [1] node.val:
        return False

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

A==

B>=

C<

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>=' for the condition

Checking right child instead of left child

In a BST, the left child's value must be less than the current node's value. If it is greater or equal, it's not a BST.

3fill in blank

hard

Fix the error in the recursive call to check the right subtree.

DSA Python

def is_bst(node):
    if node.right and not is_bst([1]):
        return False

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

Anode.right

Bnode.val

Cnode

Dnode.left

Attempts:

3 left

💡 Hint

Common Mistakes

Calling is_bst on node.left instead of node.right

Passing node.val instead of a node

To check the right subtree, we must recursively call is_bst on node.right.

4fill in blank

hard

Fill both blanks to complete the function that checks BST property using min and max limits.

DSA Python

def is_bst_util(node, min_val, max_val):
    if node is None:
        return True
    if node.val [1] min_val or node.val [2] max_val:
        return False

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

A<=

B>

C>=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using < or > instead of <= or >=

Swapping min_val and max_val in comparisons

The node's value must be greater than min_val and less than max_val. If it is less or equal to min_val or greater or equal to max_val, it violates BST rules.

5fill in blank

hard

Fill all three blanks to complete the recursive calls for left and right subtrees with updated limits.

DSA Python

def is_bst_util(node, min_val, max_val):
    if node is None:
        return True
    if node.val <= min_val or node.val >= max_val:
        return False
    return is_bst_util(node.[1], min_val, node.val) and is_bst_util(node.[2], [3], max_val)

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

Aleft

Bright

Cnode.val

Dmin_val

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping left and right in recursive calls

Using min_val or max_val incorrectly in parameters

For the left subtree, we call is_bst_util with max_val updated to node.val. For the right subtree, min_val is updated to node.val. The recursive calls use node.left and node.right respectively.

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