Implement a binary search tree in Java

To implement the binary search tree (BST) in Java, first define the node class, then create the BST class management tree structure, and then implement the insertion and search logic. 1. Define the Node class, including values ​​and left and right child nodes; 2. Create the BinarySearchTree class and set the root node; 3. Implement the insert method, find the correct position through recursion and insert a new node; 4. Add a search method to find the target value recursively according to the size comparison; 5. Optionally implement inorder and other traversal methods to verify the tree structure. The above steps constitute a BST with basic insertion, search and traversal functions.

Implementing a binary search tree (BST) in Java isn't too bad once you understand the structure and logic behind it. The key idea is that each node has at most two children, with the left child being smaller than the parent and the right child being larger.

Let's walk through how to build a basic BST in Java — from defining the node class to inserting values ​​and searching for them.

Define the Node Class

Every node in a BST holds a value and references to its left and right children. So first, we need a Node class:

 class Node {
    int value;
    Node left, right;

    public Node(int item) {
        value = item;
        left = right = null;
    }
}

This is straightforward — just an integer value and two points. You can make this more flexible by using generics if you want to support other data types later.

Create the BST Class

Next, create a class to manage the tree. It usually starts with a root node:

 class BinarySearchTree {
    Node root;

    public BinarySearchTree() {
        root = null;
    }

    // Methods will go here
}

This class will hold all the operations like insert, search, delete, etc.

Implement Insertion Logic

Inserting into a BST follows a simple rule: smaller values ​​go to the left, bigger ones to the right.

Here's how the insert method works:

• If the tree is empty, create a new node as the root.
• Otherwise, traverse the tree to find the correct spot.

Here's what the code looks like:

 void insert(int value) {
    root = insertRec(root, value);
}

Node insertRec(Node root, int value) {
    if (root == null) {
        root = new Node(value);
        return root;
    }

    if (value < root.value)
        root.left = insertRec(root.left, value);
    else if (value > root.value)
        root.right = insertRec(root.right, value);

    return root;
}

A few things to note:

• This uses recursion to find the right place to insert.
• Duplicates are typically not allowed in a standard BST, so we skip equal values ​​here.
• You could also write this iteratively if you prefer loops over recursion.

Add Search Functionality

Searching follows the same logic as insertion — compare values ​​and move left or right accordingly.

Here's a simple recursive search method:

 boolean search(int value) {
    return searchRec(root, value);
}

boolean searchRec(Node root, int value) {
    if (root == null)
        return false;

    if (root.value == value)
        return true;

    return value < root.value
           ? searchRec(root.left, value)
           : searchRec(root.right, value);
}

This returns true if the value is found, false otherwise.

If you're working on a more advanced version, you might also want to return the actual node instead of a boolean.

Optional: Add Traversal Methods

To see your tree in action, implement traversal methods like inorder, preorder, or postorder. Inorder traversal gives values ​​in sorted order — which is handy for testing.

Here's an example of inorder traversal:

 void inorder() {
    inorderRec(root);
}

void inorderRec(Node root) {
    if (root != null) {
        inorderRec(root.left);
        System.out.print(root.value " ");
        inorderRec(root.right);
    }
}

This helps visualize the structure and verify that insertion works correctly.

At this point, you have a working binary search tree with insert, search, and traversal capabilities. There's more you can do — like deletion or balancing — but those are next steps. For many use cases, especially learning or small applications, this setup is perfectly fine.

Basically that's it.

The above is the detailed content of Implement a binary search tree in Java. For more information, please follow other related articles on the PHP Chinese website!