Validate interval list symmetric

Question

Determine if a given linked list satisfies the valid BST property.

Codemia · Accepted Answer

To determine if a linked list satisfies the valid BST property, we need to ensure 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. This problem can be approached using a depth-first traversal (DFS) strategy because it allows us to explore each branch of the tree recursively while keeping track of the valid range of values for each node. By maintaining lower and upper bounds for each node, we can easily validate the BST property.

1. **Define a recursive function** that takes the current node and its valid value bounds (lower and upper) as parameters. 
2. **Base Case**: If the current node is null, return True (an empty subtree is valid). 
3. **Check the current node's value**: If the node's value is less than or equal to the lower bound or greater than or equal to the upper bound, return False. 
4. **Recursively check the left subtree** by calling the function with the current node's value as the new upper bound. 
5. **Recursively check the right subtree** by calling the function with the current node's value as the new lower bound. 
6. Return True only if both subtrees are valid.

**Example**: For the linked list representation of BST: 2 -> 1 -> 3, the function will validate as follows: 
- Start with bounds (-inf, inf) for the root (2). 
- Left child (1) checks bounds (-inf, 2) -> valid. 
- Right child (3) checks bounds (2, inf) -> valid.

```python
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def isValidBST(root):
    def validate(node, lower=float('-inf'), upper=float('inf')):
        if not node:
            return True
        val = node.val
        if val <= lower or val >= upper:
            return False
        return (validate(node.left, lower, val) and 
                validate(node.right, val, upper))
    return validate(root)
```

The time complexity of this solution is O(n), where n is the number of nodes in the linked list. This is because we visit each node exactly once during the depth-first search. The space complexity is O(h), where h is the height of the tree, due to the recursive call stack. In the worst case (skewed tree), h would be O(n), but in a balanced tree, it would be O(log n).

1. **Empty Tree**: If the linked list is empty (root is None), the function should return True since an empty tree is a valid BST. 
2. **Single Node**: If there is only one node, it should return True, as a single node tree is also a valid BST. 
3. **Duplicate Values**: If the linked list contains duplicate values, the function should return False because duplicates are not allowed in a BST. 
4. **Large Values**: Ensure the algorithm works with large integer values, testing boundaries like INT_MAX and INT_MIN.

Validate interval list symmetric

MongoDB

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Problem Analysis

Approach

Submit Your Answer

MongoDB Software Engineer Interview Guide

Related Questions

Binary Search on graph

Count kth largest element in array

Find connected components in string

Merge Three Sorted strings

Binary Search on string