Binary search trees

# Node holds a value and up to two children
class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

# Recursive insertion: compare, then repeat one level down
def insert(node, value):
    if node is None:
        return Node(value)
    if value < node.value:
        node.left = insert(node.left, value)
    else:
        node.right = insert(node.right, value)
    return node

# Recursive search: same left/right comparison, no insertion
def search(node, value):
    if node is None:
        return False       # ran out of tree: not found
    if value == node.value:
        return True        # found it
    if value < node.value:
        return search(node.left, value)
    return search(node.right, value)

# Preorder: visit the node BEFORE its children
def preorder(node):
    if node is not None:
        print(node.value)
        preorder(node.left)
        preorder(node.right)

# Inorder: visit the node IN BETWEEN its children (ascending order on a BST)
def inorder(node):
    if node is not None:
        inorder(node.left)
        print(node.value)
        inorder(node.right)

# Postorder: visit the node AFTER both its children
def postorder(node):
    if node is not None:
        postorder(node.left)
        postorder(node.right)
        print(node.value)

// Node holds a value and up to two children
class Node {
    int value;
    Node left;
    Node right;
    Node(int value) {
        this.value = value;
    }
}

// Recursive insertion: compare, then repeat one level down
Node insert(Node node, int value) {
    if (node == null) {
        return new Node(value);
    }
    if (value < node.value) {
        node.left = insert(node.left, value);
    } else {
        node.right = insert(node.right, value);
    }
    return node;
}

// Recursive search: same left/right comparison, no insertion
boolean search(Node node, int value) {
    if (node == null) {
        return false;       // ran out of tree: not found
    }
    if (value == node.value) {
        return true;        // found it
    }
    if (value < node.value) {
        return search(node.left, value);
    }
    return search(node.right, value);
}

// Preorder: visit the node BEFORE its children
void preorder(Node node) {
    if (node != null) {
        System.out.println(node.value);
        preorder(node.left);
        preorder(node.right);
    }
}

// Inorder: visit the node IN BETWEEN its children (ascending order on a BST)
void inorder(Node node) {
    if (node != null) {
        inorder(node.left);
        System.out.println(node.value);
        inorder(node.right);
    }
}

// Postorder: visit the node AFTER both its children
void postorder(Node node) {
    if (node != null) {
        postorder(node.left);
        postorder(node.right);
        System.out.println(node.value);
    }
}