java实现二叉排序树的建立，查找，插入，删除

package com.algorithm.tree;

public class BSTree<T extends Comparable> {
	private T data;
	private BSTree<T> left;
	private BSTree<T> right;
	
	public static <T extends Comparable> BSTree<T> createBSTree(T[] array){         /*建立二叉平衡树*/
		BSTree<T> root=new BSTree<T>();
		BSTree<T> p=root;
		int length=array.length;
		if(length==0) return null;
		p.data=array[0];
		int i=1;
		while(i<length){
			if(array[i].compareTo(p.data)<0){
				p.left=new BSTree<T>();
				p=p.left;
				p.data=array[i++];
			}else if(array[i].compareTo(p.data)>0){
				p.right=new BSTree<T>();
				p=p.right;
				p.data=array[i++];
			}
		}
		return root;
	}
	
	public BSTree<T> search(T data){             /*找到返回该节点，找不到返回空*/
		BSTree<T> bstree=this;
		while(bstree!=null){
			if(bstree.data.compareTo(data)>0)
				bstree=bstree.left;
			else if(bstree.data.compareTo(data)<0)
				bstree=bstree.right;
			else 
				return bstree;
		}
		return null;
	}
	
	public boolean insert(T data){               /*插入成功返回true，插入重复元素返回发绿色*/
		BSTree<T> p=this;
		BSTree<T> pre=p;
		while(p!=null){
			if(p.data.compareTo(data)>0){
				pre=p;
				p=p.left;
			}else if(p.data.compareTo(data)<0){
				pre=p;
				p=p.right;
			}else{
				return false;
			}
		}
		if(pre.data.compareTo(data)>0){
			(pre.left=new BSTree<T>()).data=data;
		}else{
			(pre.right=new BSTree<T>()).data=data;
		}
		return true;
	}
	
	public boolean delete(T data){        /*如果存在该节点则删除并返回true；如果不存在返回false*/
		BSTree<T> p=this;
		BSTree<T> pre=this;
		while(p!=null){
			if(p.data.compareTo(data)>0){
				pre=p;
				p=p.left;
			}else if(p.data.compareTo(data)<0){
				pre=p;
				p=p.right;
			}else{
				if(p.left==null) 
					p=p.right;
				else if(p.right==null) 
					p=p.left;
				else{
					BSTree<T> right=p.right;
					BSTree<T> left=p.left;
					while(left.right!=null){
						left=left.right;
					}
					left.right=right;
				}

<span style="white-space:pre">				</span>p=p.left;
				if(pre.data.compareTo(data)>0) pre.left=p;
				if(pre.data.compareTo(data)<0) pre.right=p;
			}
		}
		if(p!=null) return true;
		else return false;
	}
	
	public String inOrderTraverse(BSTree<T> root){
		if(root!=null){
			return inOrderTraverse(root.left)+root.data.toString()+","+inOrderTraverse(root.right);
		}else
			return "";
	}
	@Override
	public String toString() {
		String string=inOrderTraverse(this);
		string=string.substring(0, string.length()-1);
		return "BSTree [" + string + "]";
	}


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BSTree<Integer> bstree=BSTree.createBSTree(new Integer[]{1,2,3,4,5,6,7,8});
		System.out.println(bstree);
		BSTree<Integer> b=bstree.search(6);
		if(b!=null){
			System.out.println(b.data);
		}else
			System.out.println("null");
		bstree.insert(10);
		System.out.println(bstree);
		bstree.delete(6);
		System.out.println(bstree);
	}

}

输出结果：

BSTree [1,2,3,4,5,6,7,8]
6
BSTree [1,2,3,4,5,6,7,8,10]
BSTree [1,2,3,4,5,7,8,10]