Grok vs Kimi for Coding

class Node:
    """
    Node class for Binary Search Tree (BST).
    Each node holds data and pointers to left and right children.
    """
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

class BinarySearchTree:
    """
    Binary Search Tree (BST) implementation with insert, search, and delete operations.
    Properties:
    - Left subtree nodes < parent < right subtree nodes.
    - No duplicates allowed (insert skips if exists).
    Time Complexity (all operations):
    - Average: O(log n) where n is number of nodes (balanced tree).
    - Worst: O(n) (skewed tree, e.g., sorted input).
    Space Complexity: O(h) for recursion stack, where h is height (avg log n, worst n).
    """
    def __init__(self):
        self.root = None

    def insert(self, data):
        """
        Inserts a value into the BST.
        Edge cases handled:
        - Empty tree: creates new root.
        - Duplicate value: skips insertion.
        """
        def _insert(root, data):
            if root is None:
                return Node(data)
            if data < root.data:
                root.left = _insert(root.left, data)
            elif data > root.data:
                root.right = _insert(root.right, data)
            # Skip if data == root.data (no duplicates)
            return root
        
        self.root = _insert(self.root, data)
        # Time: O(h)

    def search(self, data):
        """
        Searches for a value in the BST.
        Returns True if found, False otherwise.
        Edge cases handled:
        - Empty tree: False.
        - Value not found: False.
        """
        def _search(root, data):
            if root is None:
                return False
            if root.data == data:
                return True
            if data < root.data:
                return _search(root.left, data)
            return _search(root.right, data)
        
        return _search(self.root, data)
        # Time: O(h)

    def delete(self, data):
        """
        Deletes a value from the BST if it exists.
        Edge cases handled:
        - Empty tree: no-op.
        - Value not found: no-op.
        - Node with no children (leaf): removed.
        - Node with one child: replaced by child.
        - Node with two children: replaced by inorder successor (min in right subtree),
          then delete successor.
        - Deleting root: updates self.root correctly.
        """
        def min_value_node(node):
            """Finds the minimum value node in a subtree (leftmost)."""
            current = node
            while current.left:
                current = current.left
            return current

        def _delete(root, data):
            if root is None:
                return root  # Not found, no-op

            if data < root.data:
                root.left = _delete(root.left, data)
            elif data > root.data:
                root.right = _delete(root.right, data)
            else:
                # Node to delete found
                if root.left is None:
                    return root.right  # No left child
                elif root.right is None:
                    return root.left   # No right child

                # Two children: get inorder successor
                temp = min_value_node(root.right)
                root.data = temp.data  # Copy successor data
                root.right = _delete(root.right, temp.data)  # Delete successor

            return root
        
        self.root = _delete(self.root, data)
        # Time: O(h)

# Example usage (for testing):
# bst = BinarySearchTree()
# bst.insert(50)
# bst.insert(30)
# bst.insert(70)
# bst.insert(20)
# bst.insert(40)
# print(bst.search(30))  # True
# bst.delete(30)
# print(bst.search(30))  # False

This implementation is complete, recursive for simplicity (suitable for most practical BST sizes), and handles all specified edge cases. It maintains BST properties throughout. For very large trees, iterative versions could avoid recursion depth limits.

Here's a complete Python implementation of a Binary Search Tree with comprehensive edge case handling:

class Node:
    """Represents a node in the Binary Search Tree."""
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None


class BinarySearchTree:
    def __init__(self):
        """Initialize an empty BST."""
        self.root = None

    def insert(self, key):
        """
        Insert a key into the BST.
        
        Time Complexity: O(h) where h is the height of the tree
        - Balanced tree: O(log n)
        - Skewed tree (worst case): O(n)
        Space Complexity: O(h) for recursion stack
        """
        # Edge case: Handle None key
        if key is None:
            raise ValueError("Cannot insert None value")
            
        self.root = self._insert_recursive(self.root, key)

    def _insert_recursive(self, node, key):
        """Helper method for recursive insertion."""
        # Base case: Found the position to insert
        if node is None:
            return Node(key)
        
        # Edge case: Handle duplicates (skip insertion or update based on requirements)
        if key == node.key:
            # Option 1: Skip duplicates (BST typically doesn't allow duplicates)
            return node
            # Option 2: If duplicates allowed, go to right subtree:
            # node.right = self._insert_recursive(node.right, key)
        
        # Recursively find the correct position
        if key < node.key:
            node.left = self._insert_recursive(node.left, key)
        else:
            node.right = self._insert_recursive(node.right, key)
            
        return node

    def search(self, key):
        """
        Search for a key in the BST.
        Returns the Node if found, None otherwise.
        
        Time Complexity: O(h) where h is the height of the tree
        - Best/Average: O(log n)
        - Worst case: O(n)
        Space Complexity: O(h) for recursion stack (O(1) for iterative)
        """
        return self._search_recursive(self.root, key)

    def _search_recursive(self, node, key):
        """Helper method for recursive search."""
        # Edge case: Empty tree or key not found
        if node is None:
            return None
        
        # Found the key
        if key == node.key:
            return node
        
        # Search left or right subtree
        if key < node.key:
            return self._search_recursive(node.left, key)
        else:
            return self._search_recursive(node.right, key)

    def delete(self, key):
        """
        Delete a key from the BST.
        
        Time Complexity: O(h) where h is the height of the tree
        - Balanced tree: O(log n)
        - Skewed tree: O(n)
        Space Complexity: O(h) for recursion stack
        
        Handles three cases:
        1. Node is a leaf (no children)
        2. Node has one child
        3. Node has two children (replace with inorder successor)
        """
        self.root = self._delete_recursive(self.root, key)

    def _delete_recursive(self, node, key):
        """Helper method for recursive deletion."""
        # Edge case: Key not found in tree
        if node is None:
            return None
        
        # Navigate to the node to delete
        if key < node.key:
            node.left = self._delete_recursive(node.left, key)
        elif key > node.key:
            node.right = self._delete_recursive(node.right, key)
        else:
            # Found the node to delete
            
            # Case 1: Leaf node (no children)
            if node.left is None and node.right is None:
                return None
            
            # Case 2: Node with only one child
            if node.left is None:
                return node.right
            if node.right is None:
                return node.left
            
            # Case 3: Node with two children
            # Find inorder successor (smallest in right subtree)
            successor = self._find_min(node.right)
            
            # Copy successor's value to current node
            node.key = successor.key
            
            # Delete the successor from right subtree
            node.right = self._delete_recursive(node.right, successor.key)
        
        return node

    def _find_min(self, node):
        """
        Find the node with minimum key in a subtree.
        Time Complexity: O(h)
        """
        current = node
        while current.left is not None:
            current = current.left
        return current

    def _find_max(self, node):
        """
        Find the node with maximum key in a subtree.
        Time Complexity: O(h)
        """
        current = node
        while current.right is not None:
            current = current.right
        return current

    def get_height(self):
        """Calculate height of tree. Time: O(n)"""
        return self._get_height_recursive(self.root)
    
    def _get_height_recursive(self, node):
        if node is None:
            return -1
        return 1 + max(self._get_height_recursive(node.left),
                       self._get_height_recursive(node.right))

    def inorder_traversal(self):
        """
        Returns sorted list of keys (BST property).
        Time Complexity: O(n)
        """
        result = []
        self._inorder_recursive(self.root, result)
        return result

    def _inorder_recursive(self, node, result):
        if node:
            self._inorder_recursive(node.left, result)
            result.append(node.key)
            self._inorder_recursive(node.right, result)


# Example usage and edge case testing
if __name__ == "__main__":
    bst = BinarySearchTree()
    
    # Test insertion
    print("Inserting: 50, 30, 70, 20, 40, 60, 80")
    for val in [50, 30, 70, 20, 40, 60, 80]:
        bst.insert(val)
    
    print("Inorder traversal:", bst.inorder_traversal())
    
    # Test search
    print("\nSearch 40:", "Found" if bst.search(40) else "Not found")
    print("Search 100:", "Found" if bst.search(100) else "Not found")
    
    # Test deletion edge cases
    print("\nDeleting leaf node (20)...")
    bst.delete(20)
    print("Inorder after deleting 20:", bst.inorder_traversal())
    
    print("\nDeleting node with one child (30)...")
    bst.delete(30)
    print("Inorder after deleting 30:", bst.inorder_traversal())
    
    print("\nDeleting node with two children (50 - root)...")
    bst.delete(50)
    print("Inorder after deleting 50:", bst.inorder_traversal())
    
    # Edge case: Delete from empty tree
    empty_bst = BinarySearchTree()
    empty_bst.delete(10)  # Should not raise error
    print("\nDeleted from empty tree successfully")
    
    # Edge case: Delete non-existent key
    bst.delete(999)  # Should not raise error
    print("Deleted non-existent key successfully")

Key Features and Edge Cases Handled:

1. Duplicate Handling: The implementation skips duplicate insertions (standard BST behavior), but you can modify to allow duplicates by placing them in the right subtree.

2. Delete Operations:

   • Leaf nodes: Simply remove the reference
   • Single child: Promote the child to replace the deleted node
   • Two children: Replace with inorder successor (minimum of right subtree) to maintain BST properties

3. Empty Tree Operations: All methods safely handle empty trees (root = None)

4. Non-existent Keys: Search returns None, delete operations complete silently without error

5. Root Node Deletion: Special handling ensures tree structure remains valid when deleting the root

Time Complexity Summary:

Operation	Average Case	Worst Case
Insert	O(log n)	O(n)
Delete	O(log n)	O(n)
Search	O(log n)	O(n)

Note: Worst case occurs when the tree becomes a linked list (skewed). For guaranteed O(log n) operations, consider implementing a self-balancing BST like AVL or Red-Black Tree.