使用toString()方法前序遍历打印二叉搜索树

二叉搜索树类

import java.util.Comparator;

public class BinarySearchTree<E>{
    //节点的数量
    private int size;
    //根节点
    private Node<E> root;
    //比较器
    private Comparator<E> comparator;
    
    //二叉搜索树的节点
    //包括节点的父节点
    //节点的左右子节点
    //节点上的元素
    private class Node<E>{
        Node<E> left;
        Node<E> right;
        Node<E> parent;
        E element;
        
        public Node(Node<E> parent,E element){
            this.parent = parent;
            this.element = element;
        }
        
        
    }
    
    public BinarySearchTree(){
        this(null);
    }
    
    public BinarySearchTree(Comparator<E> comparator){
        this.comparator = comparator;
    }
    
    
    public void add(E element){
        //二叉搜索树的元素不能为空，因为空值无法比较
        elementNotNullCheck(element);
        
        //添加的是第一个节点
        if(root == null){
        	root = new Node<E>(null,element);    
            size++;
            return;
        }
        
        //添加的不是第一个节点
        //找到父节点
        Node<E> parent = null;
        //从根节点开始比较大小
        Node<E> node = root;
        int cmp = 0;
        while(node != null){
            //记录元素比较的大小,如果添加的元素比节点元素大，则往右走；反之往左走
            cmp = compare(element,node.element);
            //记录下一个节点的父节点，以便于之后添加元素
            parent = node;
            if(cmp > 0){
                node = node.right;
            }else if(cmp < 0){
                node = node.left;
            }else{
                node.element = element;
                return;
            }
        }

        Node<E> newNode = new Node<E>(parent,element);
        
        //如果比较结果大于零，就添加元素到父节点的右节点；
        //反之，添加元素到父节点的左节点。
        if(cmp > 0){
            parent.right = newNode;
        }else{
            parent.left = newNode;
        }
        
        //将节点数量加一
        size++;
        
    }
    
    //比较方法，
    //如果创建二叉搜索树对象定义了比较器则使用比较器进行比较；
    //如果创建二叉搜索树对象没有定义比较器，那么E元素中必须要实现compareTo()方法，因为
    //不是实现这个方法，就无法比较元素的大小，也就无法创建二叉搜索树
    private int compare(E e1,E e2){
        if(comparator != null){
            return comparator.compare(e1,e2);
        }
        return ((Comparable<E>)e1).compareTo(e2);
    }
    
    
    
    //二叉搜索树的元素不能为空，因为空值无法比较
    private void elementNotNullCheck(E element){
        if(element == null){
            throw new IllegalArgumentException("element must not be null");
        }
    }
    
    //重写打印方法
    public String toString(){
        StringBuilder sb = new StringBuilder();
        toString(sb,root,"");
        return sb.toString();
    }
    
	/**
	 * 
	 * @param sb 拼接字符串stringbuilder
	 * @param node 节点
	 * @param prefix 拼接前缀
	 * @return
	 */
    public String toString(StringBuilder sb,Node<E> node,String prefix){
        if(node == null)return sb.toString();
        sb.append(prefix)
          .append("【").append(node.element).append("】")
          .append("\n");
        toString(sb,node.left,prefix + "【L】");
        toString(sb,node.right,prefix + "【R】");
        
        return sb.toString();
    }
    
}

测试类

public class Test {
	public static void main(String[] args){
        //创建integer类型的数组data
        Integer[] data = new Integer[]{
            7,4,9,2,5,8,11,3,12,1
        };
        
        //创建integer类型的二叉搜索树bst
        //integer已经实现了comparable接口的compareTo()方法
        //所以就不需要自定义比较器了。
        BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>();
        
        for(int i = 0;i < data.length;i++){
            bst.add(data[i]);
        }
        
        System.out.println(bst);
    }
}

要测试的二叉搜索树

测试截图