java实现二分搜索树BST

package Tree;

import java.awt.image.RescaleOp;

import javax.sound.midi.Soundbank;

/**
* @Title: BST.java
* @Package BinarySerachTree
* @Description: TODO二分搜索树，递归的写法一般具有更高的开销
* @author YEXIN
* @date 2019年8月27日
* @version V1.0
* @Company HUST
*/

/**
 *
 * @author YEXIN
 *二分搜索树必须的类型必须是可比较的，所以E继承Comparable
 * @param <E>
 */
public class BST<E extends Comparable<E>> {
    
    //节点类，对用户屏蔽
    private class Node{
        public E e;//节点的存储元素
        public Node left,right;//节点的做孩子和右孩子
        
        
        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
            
        }
            
    }
    
    private Node root;//二分搜索树的根节点
    private int size;//二分搜索树的节点个数
    
    public BST() {
        root = null;
        size = 0;
    }
    
    public int size() {
        return size;
    }
    
    public boolean isEmpty() {
        return size==0;
    }
    
    /**
     * ：递归实现
     * 为二分搜索树添加元素,不包含元素
     *
     */
    //用户调用
    public void add(E e) {
        root = addToTree(root, e);        
    }
    
    //对用户隐蔽
    //向以node为根节点的二分搜索树插入元素e，递归算法
    //因为在比较过程中要插入的二分搜索树在不断变小，所以node每次传入的参数也在改变
    private Node addToTree(Node node,E e) {
        
        //终止条件
        if (node == null) {
            size ++;
            return new Node(e);
            
        }
        if (e.compareTo(node.e)<0) {
            node.left = addToTree(node.left, e);
        }else if (e.compareTo(node.e)>0) {
            node.right = addToTree(node.right, e);
        }
        
        return node;
        
    }
    
    //查询是否包含元素,开放给用户
    public boolean contains(E e) {
        return contains(root,e);

    }
    //自己私有的，对用户屏蔽，查看以node为根的二分搜索树是否含有元素e，递归算法
    private boolean contains(Node node,E e) {
        if (node == null) {
            return false;
        }
        if (e.compareTo(node.e) == 0) {
            return true;
        }else if (e.compareTo(node.e)>0) {
            return contains(node.right,e);
        }else //(e.compareTo(node.e)<0) {
            return contains(node.left,e);
    }
//======================================================    
    //前序遍历，先访问根，再左子树，再右子树
    public void preOrder() {
        preOrder(root);
    }
    //前序遍历以node为根节点的二分搜索树
    private void preOrder(Node node) {
        if (null == node) {
            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.println(node.e);
        inOrder(node.right);
    }
 //====================================================
    //后序遍历,用于内存释放，先遍历左右子树
    public void postOrder() {
        postOrder(root);
    }
    
    private void postOrder(Node node) {
        if (node == null) {
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);
    }
 //====================================================
 
    @Override//直接将对象转为字符串的方法，需要自己实现
    public String toString() {
        StringBuilder res = new StringBuilder();
        grenerateBSTString(root,0,res);
        
        return res.toString();
    }
    
    //生成node为根节点，深度为depth的二叉树的字符串
    private void grenerateBSTString(Node node,int depth,StringBuilder res) {
        if (node == null) {
            res.append(getDepthString(depth)+"null\n");
            return;//不能省略，作为访问到最后节点时终止操作。
        }
        res.append(getDepthString(depth)+node.e+"\n");
        grenerateBSTString(node.left, depth+1, res);
        grenerateBSTString(node.right, depth+1, res);
    }
                 
    private String getDepthString(int depth) {
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            res.append("--");
        }
         return res.toString();
    }

    public static void main(String[] args) {
        System.out.println("------BST--------");
        
        BST<Integer> bst = new BST<Integer>();
        int[] arr = {5,3,6,8,4,2};
        for (int i : arr) {
            bst.add(i);
        }
        System.out.println("========前序遍历=======");
        bst.preOrder();
        System.out.println("===============");
        System.out.println(bst);
        System.out.println("========中序遍历=======");
        bst.inOrder();
        System.out.println("========后序遍历=======");
        bst.postOrder();
                
        
    }
}

==========================

------BST--------
========前序遍历=======
5
3
2
4
6
8
===============
5
--3
----2
------null
------null
----4
------null
------null
--6
----null
----8
------null
------null

========中序遍历=======
2
3
4
5
6
8
========后序遍历=======
2
4
3
8
6
5