Master Binary Trees - Interactive Tutorial

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

class BinarySearchTree:
    def __init__(self):
        self.root = None

    def insert(self, value):
        """Insert value into BST - O(log n) average"""
        if not self.root:
            self.root = TreeNode(value)
            return
        
        current = self.root
        while True:
            if value < current.value:
                if not current.left:
                    current.left = TreeNode(value)
                    break
                current = current.left
            else:
                if not current.right:
                    current.right = TreeNode(value)
                    break
                current = current.right

    def search(self, value):
        """Search for value - O(log n) average"""
        current = self.root
        while current:
            if value == current.value:
                return True
            elif value < current.value:
                current = current.left
            else:
                current = current.right
        return False

    def inorder(self, node, result):
        """Inorder traversal: Left -> Root -> Right"""
        if node:
            self.inorder(node.left, result)
            result.append(node.value)
            self.inorder(node.right, result)

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

class BinarySearchTree {
    constructor() {
        this.root = null;
    }

    insert(value) {
        const newNode = new TreeNode(value);
        
        if (!this.root) {
            this.root = newNode;
            return;
        }

        let current = this.root;
        while (true) {
            if (value < current.value) {
                if (!current.left) {
                    current.left = newNode;
                    break;
                }
                current = current.left;
            } else {
                if (!current.right) {
                    current.right = newNode;
                    break;
                }
                current = current.right;
            }
        }
    }

    search(value) {
        let current = this.root;
        while (current) {
            if (value === current.value) return true;
            current = value < current.value ? current.left : current.right;
        }
        return false;
    }

    inorder(node = this.root, result = []) {
        if (node) {
            this.inorder(node.left, result);
            result.push(node.value);
            this.inorder(node.right, result);
        }
        return result;
    }
}

package main

type TreeNode struct {
    Value int
    Left  *TreeNode
    Right *TreeNode
}

type BST struct {
    Root *TreeNode
}

func (bst *BST) Insert(value int) {
    if bst.Root == nil {
        bst.Root = &TreeNode{Value: value}
        return
    }

    current := bst.Root
    for {
        if value < current.Value {
            if current.Left == nil {
                current.Left = &TreeNode{Value: value}
                break
            }
            current = current.Left
        } else {
            if current.Right == nil {
                current.Right = &TreeNode{Value: value}
                break
            }
            current = current.Right
        }
    }
}

func (bst *BST) Search(value int) bool {
    current := bst.Root
    for current != nil {
        if value == current.Value {
            return true
        } else if value < current.Value {
            current = current.Left
        } else {
            current = current.Right
        }
    }
    return false
}

func Inorder(node *TreeNode, result *[]int) {
    if node != nil {
        Inorder(node.Left, result)
        *result = append(*result, node.Value)
        Inorder(node.Right, result)
    }
}

class TreeNode {
    int value;
    TreeNode left, right;

    public TreeNode(int value) {
        this.value = value;
        left = right = null;
    }
}

class BinarySearchTree {
    TreeNode root;

    public void insert(int value) {
        if (root == null) {
            root = new TreeNode(value);
            return;
        }

        TreeNode current = root;
        while (true) {
            if (value < current.value) {
                if (current.left == null) {
                    current.left = new TreeNode(value);
                    break;
                }
                current = current.left;
            } else {
                if (current.right == null) {
                    current.right = new TreeNode(value);
                    break;
                }
                current = current.right;
            }
        }
    }

    public boolean search(int value) {
        TreeNode current = root;
        while (current != null) {
            if (value == current.value) return true;
            current = value < current.value ? current.left : current.right;
        }
        return false;
    }

    public void inorder(TreeNode node) {
        if (node != null) {
            inorder(node.left);
            System.out.print(node.value + " ");
            inorder(node.right);
        }
    }
}