binary search/sort tree based on Java

Definition of BST

1. If its left subtree is not empty, the value of all nodes in the left subtree is less than the value of its root structure.
2. If its right subtree is not empty, the value of all nodes in the right subtree is greater than the value of its root structure.
3. Its left and right subtrees are also binary sort trees (recursion).

• Note: elements in the tree are repeatable, that means, they can be changed to >= or <=.

• Why is it called a binary sort tree?
• Because the sequence in BST is an ordered sequence, the construction of a binary sort tree for an arbitrary keyword sequence is to sort it and make it into an ordered sequence

source code

public class Bst {
    static class BSTNode{ // this is a internal class
        private int key;
        private BSTNode lc = null;
        private BSTNode rc = null;
    }
    public static void main(String[] args) {
        int[] a = new int[]{2,3,54,1,5,0,5,3,2,1};
        BSTNode b = CreateBST(a);
        DispBST(b);
        InsertBST(b, 7);
        System.out.println();
        DispBST(b);
        System.out.println();
        InOrder(b); //InOrder traversal
    }
    public static BSTNode CreateBST(int[] a){
        BSTNode bst = null;
        for(int i = 0; i < a.length; i++){
            bst = InsertBST(bst, a[i]);
        }
        return bst;
    }
    public static BSTNode InsertBST(BSTNode b, int k){ // Insert a data in bst
        if(b == null){
            b = new BSTNode();
            b.key = k;
            b.lc = null;
            b.rc = null;
            return b;
        }
        if(b.key > k) b.lc = InsertBST(b.lc, k);
        else b.rc = InsertBST(b.rc, k); 
        return b;
    }

    public static void DispBST(BSTNode bstNode){ //parenthesized notation
        if(bstNode != null){
            System.out.print(bstNode.key);
            if(bstNode.rc != null || bstNode.lc != null){
                System.out.print("(");
                DispBST(bstNode.lc);
                if(bstNode.rc != null) System.out.print(",");
                DispBST(bstNode.rc);
                System.out.print(")");
            }
        }
    }
    public static void InOrder(BSTNode bstNode){//inorder traversal
        if(bstNode != null){
            InOrder(bstNode.lc);
            System.out.print(bstNode.key + " ");
            InOrder(bstNode.rc);
        }
    }

output

2(1(0,1),3(2,54(5(3,5))))
2(1(0,1),3(2,54(5(3,5(,7)))))
0 1 1 2 2 3 3 5 5 7 54 

BST complexity analysis

• BST is more efficient in terms of maintaining the orderliness of the table, because you don’t have to move the elements, just modify the pointer to complete the insertion and deletion of nodes
  The average execution time is $$O(lo{g}_{2}n)$$