bst generics

import java.util.ArrayList;
import java.util.List;

class TreeNode<T extends Comparable<T>> {
    T value;
    TreeNode<T> left;
    TreeNode<T> right;

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

public class BinarySearchTree<T extends Comparable<T>> {
    private TreeNode<T> root;

    // Method to insert a new value in the BST
    public void insert(T value) {
        root = insertRec(root, value);
    }

    private TreeNode<T> insertRec(TreeNode<T> root, T value) {
        if (root == null) {
            root = new TreeNode<>(value);
            return root;
        }
        if (value.compareTo(root.value) < 0) {
            root.left = insertRec(root.left, value);
        } else if (value.compareTo(root.value) > 0) {
            root.right = insertRec(root.right, value);
        }
        return root;
    }

    // Method for inorder traversal
    public void inorder() {
        List<T> result = new ArrayList<>();
        inorderRec(root, result);
        System.out.println("Inorder: " + result);
    }

    private void inorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            inorderRec(root.left, result);
            result.add(root.value);
            inorderRec(root.right, result);
        }
    }

    // Method for preorder traversal
    public void preorder() {
        List<T> result = new ArrayList<>();
        preorderRec(root, result);
        System.out.println("Preorder: " + result);
    }

    private void preorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            result.add(root.value);
            preorderRec(root.left, result);
            preorderRec(root.right, result);
        }
    }

    // Method for postorder traversal
    public void postorder() {
        List<T> result = new ArrayList<>();
        postorderRec(root, result);
        System.out.println("Postorder: " + result);
    }

    private void postorderRec(TreeNode<T> root, List<T> result) {
        if (root != null) {
            postorderRec(root.left, result);
            postorderRec(root.right, result);
            result.add(root.value);
        }
    }

    // Main method to test the BST
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        bst.insert(50);
        bst.insert(30);
        bst.insert(20);
        bst.insert(40);
        bst.insert(70);
        bst.insert(60);
        bst.insert(80);

        bst.inorder();   // Inorder traversal
        bst.preorder();  // Preorder traversal
        bst.postorder(); // Postorder traversal
    }
}