通过java语言对BSTree的实现
public class BSTree<E> {
private int size = 0;
private Comparator comparator;
private Node<E> root;
public BSTree(){
this(null);
}
public BSTree(Comparator comparator){
this.comparator = comparator;
}
public int size(){
return size;
}
/**
* 判空函数
* @return
*/
public boolean isEmpty(){
return size==0;
}
/**
* 清空函数
*/
public void clear(){
root = null;
size = 0;
}
/**
* 添加函数
* @param element
*/
public void add(E element){
elementNotNullCheck(element);
if (root ==null){
root = new Node<>(element,null);
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 {
return;
}
}
if (cmp>0){
parent.right = new Node<>(element,parent);
}else{
parent.left = new Node<>(element,parent);
}
size++;
}
/**
* 删除函数
* @param element
*/
public void remove(E element){
Node<E> node = getNode(element);
if (node==null) return;
size--;
//删除度为2的节点
if (node.left!=null&&node.right!=null){
Node<E> s = successor(node);
node.element = s.element;
//删除后继节点，利用删除度为0，1的代码进行删除
node = s;
}
//删除度为1，0的节点
if (node.parent==null&&node.left==null&&node.right==null) root = node;
else if (node.left==null&&node.right==null) {
if (node==node.parent.left) node.parent.left=null;
else node.parent.right=null;
}else {
Node<E> replacement = node.left !=null?node.left:node.right;
replacement.parent = node.parent;
if (node.parent==null) root = replacement;
else if (node==node.parent.left) node.parent.left=replacement;
else node.parent.right=replacement;
}
}
/**
* 寻找前驱节点
* @param node
* @return
*/
public Node<E> predecessor(Node<E> node){
if (node.left!=null){
Node<E> decessor = node.left;
while (decessor.right!=null) decessor = decessor.right;
return decessor;
}
while (node.parent!=null&&node==node.parent.left) node = node.parent;
return node.parent;
}
/**
* 寻找后继节点
* @param node
* @return
*/
public Node<E> successor(Node<E> node){
if (node.right!=null){
Node<E> successor = node.right;
while (successor.left!=null) successor = successor.left;
return successor;
}
while (node.parent!=null&&node==node.parent.right) node = node.parent;
return node.parent;
}
/**
* 是否包含该元素
* @param element
* @return
*/
public boolean contains(E element){
return getNode(element)!=null;
}
/**
* 根据值获取节点
* @param element
* @return
*/
private Node<E> getNode(E element){
Node<E> node = root;
while (node!=null){
int cmp = compare(element,node.element);
if (cmp==0) return node;
if (cmp>0) node = node.right;
else node = node.left;
}
return null;
}
/**
* 求树的深度
* @return
*/
public int height(){
if (root==null) return 0;
//树的高度
int height = 0;
Queue<Node<E>> queue = new LinkedList<>();
queue.offer(root);
//每一层节点的数目
int levelSize = 1;
while (!queue.isEmpty()){
Node<E> node = queue.poll();
levelSize--;
if (node.left!=null) queue.offer(node.left);
if (node.right!=null) queue.offer(node.right);
if (levelSize==0) {
levelSize=queue.size();
height++;
}
}
return height;
}
/**
* 前序遍历
*/
public void preOrderTraverse(Visitor<E> visitor){
if (visitor==null) return;
visitor.stop=false;
preOrderTravese(root,visitor);
}
private void preOrderTravese(Node<E> node,Visitor<E> visitor){
if (node==null||visitor.stop) return;
visitor.stop = visitor.visit(node.element);
preOrderTravese(node.left,visitor);
preOrderTravese(node.right,visitor);
}
/**
* 中序遍历
*/
public void inOrderTraverse(Visitor<E> visitor){
if (visitor == null) return;
visitor.stop = false;
inOrderTravese(root,visitor);
}
private void inOrderTravese(Node<E> node,Visitor<E> visitor){
if (node==null|| visitor.stop) return;
inOrderTravese(node.left,visitor);
if (visitor.stop) return;
visitor.stop = visitor.visit(node.element);
inOrderTravese(node.right,visitor);
}
/**
* 后续遍历
*/
public void postOrderTraverse(Visitor<E> visitor){
if (visitor==null) return;
visitor.stop = false;
postOrderTraverse(root,visitor);
}
private void postOrderTraverse(Node<E> node,Visitor<E> visitor){
if (node==null) return;
postOrderTraverse(node.left,visitor);
postOrderTraverse(node.right,visitor);
if (visitor.stop) return;
visitor.visit(node.element);
}
/**
* 层次遍历
*/
public void levelOrderTravese(Visitor<E> visitor){
if (root==null) return;
Queue<Node<E>> queue = new LinkedList<>();
visitor.stop = false;
queue.offer(root);
while (!queue.isEmpty()){
Node<E> node = queue.poll();
visitor.stop = visitor.visit(node.element);
if (visitor.stop) return;
if (node.left!=null) queue.offer(node.left);
if (node.right!=null) queue.offer(node.right);
}
}
/**
* 树形打印
*/
public void printBSTree(){
if (root==null) return;
printBSTree(root,0);
}
private void printBSTree(Node<E> node,int n){
if (node==null) return;
printBSTree(node.left,n+3);
for (int i=0;i<n;i++) System.out.print(" ");
System.out.println(node.element);
printBSTree(node.right,n+3);
}
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 null");
}
}
public static abstract class Visitor<E>{
boolean stop;
abstract boolean visit(E element);
}
private static class Node<E>{
E element;
Node<E> left;
Node<E> right;
Node<E> parent;
public Node(E element,Node<E> parent){
this.element = element;
this.parent = parent;
}
}
}
