分享一个二叉排序树算法

package com.sort;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

public class SortedBinTree<T extends Comparable> {
	static class Node {
		Object data;
		Node parent;
		Node left;
		Node right;

		public Node(Object data, Node parent, Node left, Node right) {
			this.data = data;
			this.parent = parent;
			this.left = left;
			this.right = right;
		}

		public String toString() {
			return "[data=" + data + "]";
		}

		public boolean equals(Object obj) {
			if (this == obj) {
				return true;
			}
			if (obj.getClass() == Node.class) {
				Node target = (Node) obj;
				return data.equals(target.data) && left == target.left
						&& right == target.right && parent == 

target.parent;
			}
			return false;
		}
	}
	
	private Node root;
	//构造器用于创建二叉树
	public SortedBinTree(){
		root=null;
	}
	public SortedBinTree(T o){
		root=new Node(o, null, null, null);
	}
	//添加节点
	public void add(T ele){
		//如果根节点为null
		if(root==null){
			root=new Node(ele, null, null, null);
		}else{
			Node current=root;
			Node parent=null;
			int cmp=0;
			//搜索合适的叶子节点，以该节点为父子节点添加新节点
			do{
				parent=current;
				cmp=ele.compareTo(current.data);
				//如果新节点的值大于当前节点值
				if(cmp>0){
					//以右子节点作为当前节点
					current=current.right;
				}else{
					//如果新节点值小于当前节点值
					//以左节点作为当前节点
					current=current.left;
				}
			}while(current!=null);
			//创建新节点
			Node newNode=new Node(ele, parent, null, null);
			//如果新节点的值大于父节点的值
			if(cmp>0){
				//新节点作为父节点的右子节点
				parent.right=newNode;
			}else{
				//新节点的值小于父节点的值
				//新节点作为父节点的左子节点
				parent.left=newNode;
			}
		}
	}
	//删除节点
	public void remove(T ele){
		//获取要删除的节点
		Node target=getNode(ele);
		if(target==null){
			return;
		}
		//左右子树为空
		if(target.left==null&&target.right==null){
			//被删除的节点是跟节点
			if(target==root){
				root=null;
			}else{
				//被删除节点是父节点的左子节点
				if(target==target.parent.left){
					//将target的父节点的left设为null
					target.parent.left=null;
				}else{
					//将target的父节点的right设为null
					target.parent.right=null;
				}
				target.parent=null;
			}
		}else if(target.left==null&&target.right!=null){ //左子树为空，右子树不为空
			//被删除节点是跟节点
			if(target==root){
				root=target.right;
			}else{
				//被删除节点是父节点的左子节点
				if(target==target.parent.left){
					//让target的父节点的left指向target的右子树
					target.parent.left=target.right;
				}else{
					//让target的父节点的right指向target的右子树
					target.parent.right=target.right;
				}
				//让target的右子树的parent指向target的parent
				target.right.parent=target.parent;
			}
		}else if(target.left!=null&&target.right==null){ //左子树不为空，右子树为空
			//被删除的是跟节点
			if(target==root){
				root=target.left;
			}else{
				//被删除的节点是父节点的左子节点
				if(target==target.parent.left){
					//让target的父节点的left指向target的左子树
					target.parent.left=target.left;
				}else{
					//让target的父节点的right指向target的左子树
					target.parent.right=target.left;
				}
			}
		}else{ //左右子树都不为空
			//leftMaxNode用于保存target节点的左子树中值最大的节点
			Node leftMaxNode=target.left;
			//搜索target节点的左子树中值最大的节点
			while(leftMaxNode.right!=null){
				leftMaxNode=leftMaxNode.right;
			}
			//从原来的子树中删除leftMaxNod
			leftMaxNode.parent.right=null;
			//让leftMaxNode的parent指向target的parent
			leftMaxNode.parent=target.parent;
			//被删除节点是父节点的左子节点
			if(target==target.parent.left){
				//让target的父节点的left指向leftMaxNode
				target.parent.left=leftMaxNode;
			}else{
				//让target的父节点的right指向leftMaxNode
				target.parent.right=leftMaxNode;
			}
			leftMaxNode.left=target.left;
			leftMaxNode.right=target.right;
			target.parent=target.left=target.right=null;
		}
	}
	
	//给指定的值搜索节点
	public Node getNode(T ele){
		//从根节点开始搜索
		Node p=root;
		while(p!=null){
			int cmp=ele.compareTo(p.data);
			//如果搜索的值小于当前p节点的值
			if(cmp<0){
				//向左子树搜索
				p=p.left;
			}else if(cmp>0){ //如果搜索的值大于当前p节点的值
				p=p.right;
			}else{
				return p;
			}
		}
		return null;
	}
	
	//广度优先遍历
	public List<Node> breadthFirst(){
		Queue<Node> queue=new ArrayDeque<Node>();
		List<Node> list=new ArrayList<Node>();
		if(root!=null){
			//将根元素加入"队列"
			queue.offer(root);
		}
		while(!queue.isEmpty()){
			//将该队列的"队尾"的元素添加到List中
			list.add(queue.peek());
			Node p=queue.poll();
			//如果左子节点不为null,将它加入"队列"
			if(p.left!=null){
				queue.offer(p.left);
			}
			//如果右子节点不为null,将它加入"队列"
			if(p.right!=null){
				queue.offer(p.right);
			}
		}
		return list;
	}
}