自己写的一个二叉查找树,对于该树每一个节点,以该节点为根节点的子树的左侧节点均小于根节点,右侧节点均大于根节点。
package Tree.BinarySearchTree;
import java.nio.BufferUnderflowException;
/**
* @author DearAhri520
*
* 二叉查找树*/
public class BinarySearchTree<T extends Comparable<? super T>> {
/**
* 二叉树节点
*/
private static class BinaryNode<T>{
T element;
BinaryNode<T> left;
BinaryNode<T> right;
BinaryNode(T t){
this(t,null,null);
}
BinaryNode(T t,BinaryNode<T> left,BinaryNode<T> right){
this.element=t;
this.left=left;
this.right=right;
}
}
/**
* 根节点
*/
private BinaryNode<T> root;
public BinarySearchTree(){
root=null;
}
/**
* 清空二叉树
*/
public void makeEmpty(){
root=null;
}
/**
* 返回该树是否为空
*/
public boolean isEmpty(){
return root==null;
}
/**
* 返回该树是否包含节点t
* @param t 查找的节点
* @return 返回是否包含该节点
*/
public boolean contains(T t){
return contains(t,root);
}
/**
* 查找该树最小的节点
* @return 返回该树最小的节点
*/
public T findMin(){
if(isEmpty()){
throw new BufferUnderflowException();
}
return findMin(root).element;
}
/**
* 查找该树最大的节点
* @return 返回该树最大的节点
*/
public T findMax(){
if(isEmpty()){
throw new BufferUnderflowException();
}
return findMax(root).element;
}
/**
* 插入一个数据
* @param t 需要插入的数据
*/
public void insert(T t){
root=insert(t,root);
}
/**
* 移除一个数据
* @param t 需要移除的数据
*/
public void remove(T t){
root=remove(t,root);
}
/**
* 打印该二叉树
*/
public void printTree(){
if(isEmpty()){
System.out.println("Empty tree");
}else{
printTree(root);
}
}
/**
* 私有方法,判断是否包含该节点
* @param t 查找的数据
* @param binaryNode 树的根节点
* @return 返回是否包含该节点
*/
private boolean contains(T t,BinaryNode<T> binaryNode){
//如果节点为空,则表明查找不到,返回false
if(binaryNode==null){
return false;
}
//比较树的节点与查找的元素
int compareResult=t.compareTo(binaryNode.element);
//compareResult<0:向左子树查找,compareResult>0:向右子树查找,compareResult=0,返回true
if(compareResult<0){
return contains(t,binaryNode.left);
}else if(compareResult>0){
return contains(t,binaryNode.right);
}else {
return true;
}
}
/**
* 查找最小的节点
* @param binaryNode 查找的数据
* @return 返回最小的节点
*/
private BinaryNode<T> findMin(BinaryNode<T> binaryNode){
//一直向左子树查找,返回该树最左的节点
if(binaryNode==null){
return null;
}else if(binaryNode.left==null){
return binaryNode;
}
return findMin(binaryNode.left);
}
/**
* 查找最大的节点
* @param binaryNode 查找的数据
* @return 返回最大的节点
*/
private BinaryNode<T> findMax(BinaryNode<T> binaryNode){
//一直向右子树查找,返回该树最右的节点
if(binaryNode!=null){
while (binaryNode.right!=null){
binaryNode=binaryNode.right;
}
}
return binaryNode;
}
/**
*插入一个节点,返回被插入节点的引用
* @param t 想要插入的节点
* @param root 根节点
* @return 返回插入节点的引用
*/
private BinaryNode<T> insert(T t,BinaryNode<T> root){
//如果root=null,即到达树的底部,插入该节点,返回被插入的节点
if(root==null){
return new BinaryNode<>(t,null,null);
}
int compareResult = t.compareTo(root.element);
//插入的元素小于根节点,向左移动
if(compareResult<0){
root.left=insert(t,root.left);
//插入的元素大于根节点,向右移动
}else if(compareResult>0){
root.right=insert(t,root.right);
}else{
//Duplicate; do nothing
}
return root;
}
/**
* 删除一个节点,返回被删除节点的引用
* @param t 需要删除的节点
* @param root 根节点
* @return 返回删除之后节点的引用
*/
private BinaryNode<T> remove(T t,BinaryNode<T> root){
if(root==null){
return null;
}
int compareResult = t.compareTo(root.element);
//删除的元素小于根节点,向左移动
if(compareResult<0){
root.left=remove(t,root.left);
//删除的元素大于根节点,向右移动
}else if(compareResult>0){
root.right=remove(t,root.right);
//想要删除的节点的左节点与右节点均不为空,则将右子树的最小节点赋给该节点,并删除右子树的最小节点
}else if(root.left!=null&&root.right!=null){
root.element=findMin(root.right).element;
root.right=remove(root.element,root.right);
}else{
root=(root.left!=null)?root.left:root.right;
}
return root;
}
/**
* 打印整个树
* @param root 根节点
*/
private void printTree(BinaryNode<T> root){
if(root!=null){
printTree(root.left);
System.out.println(root.element);
printTree(root.right);
}
}
}