Some basic operations of binary trees (java)

First, define the node class 
public class TreeNode { 
    int val; 
    TreeNode left; 
    TreeNode right; 
    TreeNode(int val){ 
        this.val=val; 
        this.left=null; 
        this.right=null; 
    } 
}

Next, we define a binary tree and implement various methods

import java.util.LinkedList; 
import java.util.Queue; 

public class BinaryTree { 
    public TreeNode root; 
    public BinaryTree(){ 
        root=null; 
    } 


    //Insertion into the binary tree, if the element is smaller than the element, insert the left subtree of the node , if it is large, insert the right subtree 
    public void insert(int val){ 
        root=insert(root,val); 
    } 

    public TreeNode insert(TreeNode node,int val){ 
        if(node==null){ 
            node=new TreeNode(val ); 
        } 
        else { 
            if (val<=node.val){ 
                node.left=insert(node.left,val); 
            }else { 
                node.right=insert(node.right,val); 
            } 
        }
        return node; 
    } 


    //Search for nodes based on value, return true if there is one, false if not 
    public boolean search(int val){ 
        return search(root,val); 
    } 

    public boolean search(TreeNode node,int val){ 
        if (node==null){ 
            return false; 
        }else if (node.val==val){ 
            return true; 
        }else if (val<node.val){ 
            return search(node.left,val); 
        }else { 
            return search(node.right,val); 
        } 
    } 


    //Delete node 
    public void delete(int val){ 
        root=delete(root,val); 
    }

    public TreeNode delete(TreeNode node,int val){ 
        if (node==null){ 
            return null; 
        }else if (val<node.val){ 
            node.left=delete(node.left,val); 
        }else if ( val> node.val){ 
            node.right=delete(node.right,val); 
        }else { 
            //The node has been found 
            //1: The node to be deleted is a child node 
            if (node.right==null && node.left==null ){ 
                node=null; 
            } 
            //2: The node to be deleted is only the right node 
            else if (node.left==null){ 
                node=node.right; 
            } 
            //3: To be deleted The node has only the left node 
            else if (node.right==null){
                node=node.left; 
            } 
            //4: The node to be deleted has left and right nodes 
            else { 
                //Find the minimum node of the right subtree of the node 
                TreeNode temp=findMin(node.right); 
                node.val=temp .val; 
                node.right=delete(node.right,temp.val); 
            } 
        } 
        return node; 
    } 

    public TreeNode findMin(TreeNode node){ 
        while (node.left!=null){ 
            node=node.left; 
        } 
        return node; 
    } 


    //Inorder traversal 
    public void inorderTraversal(){ 
        inorderTraversal(root); 
    }
 
    public void inorderTraversal(TreeNode node){
        if (node!=null){
            inorderTraversal(node.left);
            System.out.print(node.val+" ");
            inorderTraversal(node.right);
        }
    }


    //前序遍历
    public void proOrderTraversal(){
        proOrderTraversal(root);
    }

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

    //后序遍历
    public void postOrderTraversal(){
        proOrderTraversal(root);
    }

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

    //层序遍历
    public void levelOrderTraversal(){
        if (root==null){
            return;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            TreeNode node=queue.poll();
            System.out.print(node.val+" ");
            if (node.left!=null){
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }
}

  //查找双亲结点
    public TreeNode getParent(TreeNode node){
        return findParent(root,node);
    }

    public TreeNode findParent(TreeNode root,TreeNode node){
        if (root==null || root==node){
            return null;
        }
        if (root.left==node || root.right==node){
            return root;
        }
        TreeNode parent=findParent(root.left,node);
        if (parent!=null){
            return parent;
        }
        return findParent(root.right,node);
    }

    //查找兄弟结点
    public TreeNode getSibling(TreeNode node){
        TreeNode parent=getParent(node);
        if (parent==null){
            return null;
        }
        if (parent.left==node){
            return parent.right;
        }else {
            return parent.left;
        }
    }


    //查找孩子结点
    public TreeNode[] getChildren(TreeNode node){
        TreeNode[] children=new TreeNode[2];
        children[0]=node.left;
        children[1]=node.right;
        return children;
    }
}