关于二叉搜索树的一些整理

二叉搜索树：

BST（Binary Search Tree）目的是为了提高查找的性能，其查找在平均和最坏的情况下都是logn级别，接近二分查找。
其特点是：每个节点的值大于其任意左侧子节点的值，小于其任意右节点的值。

二叉搜索树的实现：

//节点定义
private class Node{
    public E e;
    public Node left;
    public Node right;
 
    public Node(E e){
        this.e = e;
        left = null;
        right = null;
    }
}
 * public class TreeNode {//int类型的二叉树
 *     int val;//E e;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }

//成员变量如下：
private Node root;
private int size;
//初始化二叉树，定义根节点为空，元素个数为零
public BST(){
    root = null;
    size = 0;
}
	//向二分搜索树中添加元素
    //以node为根的二分搜索树中插入元素e,递归实现
    //不管左右孩子是否为空，都可以作为一个二叉树
    //只不过空的就是空的二叉树，这时就可以一直判断，知道下一节点为空，就创建一个节点返回，
    private Node add(Node node, E e){
        if (node == null){
            size++;
            return new Node(e);
        }
        //递归调用，已经有的元素不做操作
        if (e.compareTo(node.e) < 0)
            node.left = add(node.left,e);
        if (e.compareTo(node.e) > 0)
            node.right = add(node.right,e);
 
        //返回最终以node为根节点的二叉树
        return node;
    }

---

深度优先搜索：

前序、中序、后序
深度优先搜索（DFS）是从根延伸到某一片叶子，然后再返回另一个分支。根据根节点，左节点，右节点的相对顺序。

广度优先搜索：

广度优先搜索（BFS）是逐层，从上到下扫描整个树。

    //前序遍历
    public void preOrder(){
        preOrder(root);
    }
    //递归遍历
    private void preOrder(Node node){
        if (node == null)
            return;
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }
    
        //中序遍历
    public void inOrder(){
        inOrder(root);
    }
 
    private void inOrder(Node node){
        if (node == null)
            return;
 
        inOrder(node.left);
        System.out.print(node.e + " ");
        inOrder(node.right);
    }
    
        //层序遍历
    public void levelOrder(){
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){    
            Node curr = queue.remove();
            System.out.print(curr.e + " ");
            if (curr.left != null)
                queue.add(curr.left);
            if (curr.right != null) {
                queue.add(curr.right);
            }
        }
    }

---