二叉搜索树又称二叉查找树，二叉排序树，它具有以下几点特点：

    • 如果它的左子树不为空，则左子树上结点的值都小于根结点的值；
    • 如果它的右子树不为空，则右子树上结点的值都大于根结点的值；
    • 子树也同样遵循以上两点。

    下面来实现一颗二叉搜索树

    1. /**
    2.  * 二叉查找树
    3.  * @author xzf
    4.  * @date 2021/1/20 14:12
    5.  */
    6. public class SearchTree {
    8.     private int data;
    9.     SearchTree left;
    10.     SearchTree right;
    12.     public SearchTree(int data) {
    13.         this.data = data;
    14.         this.left = null;
    15.         this.right = null;
    16.     }
    18.     /**
    19.      * 插入元素
    20.      * @param root
    21.      * @param data
    22.      */
    23.     public void insert(SearchTree root,int data){
    24.         if(root.data<data){
    25.             if(root.right == null){
    26.                 // 根结点下没有子结点
    27.                 root.right = new SearchTree(data);
    28.             }else {
    29.                 insert(root.right,data);
    30.             }
    31.         }else {
    32.             if (root.left == null) {
    33.                 root.left = new SearchTree(data);
    34.             }else {
    35.                 insert(root.left,data);
    36.             }
    37.         }
    38.     }
    40.     /**
    41.      * 中序输出
    42.      * @param root
    43.      */
    44.     public void in(SearchTree root){
    45.         if(root != null) {
    46.             in(root.left);
    47.             System.out.print(root.data + " ");
    48.             in(root.right);
    49.         }
    50.     }
    52.     /**
    53.      * 查找某个元素
    54.      * @param root
    55.      * @param data
    56.      */
    57.     public SearchTree find(SearchTree root,int data){
    58.         SearchTree node = root;
    59.         while (node.data != data){
    60.           if(node.data<data){
    61.               node = node.right;
    62.           }else {
    63.               node = node.left;
    64.           }
    65.           if(node == null){
    66.               return null;
    67.           }
    68.         }
    69.        return node;
    70.     }
    72.     public static void main(String[] args) {
    73.         //快速排序，归并排序，二叉树排序
    74.         int data[] = {0,5,9,1,2,3,10};
    75.         //第一个点作为跟结点
    76.         SearchTree root = new SearchTree(data[0]);
    77.         for(int i = 1 ; i < data.length ; i ++) {
    78.             root.insert(root, data[i]);
    79.         }
    80.         System.out.println("中序遍历:");
    81.         root.in(root);
    82.         System.out.println(root.find(root,7));
    83.     }
    84. }