Rhyme/查找树ADT-二叉查找树的简单模拟Java版

查找树ADT-二叉查找树的简单模拟Java版

package my.binary.search.tree;

/**
* 查找树 ADT 二叉查找树的实现
* 假设元素类型为Integer
*
* @author RhymeChiang
* @date 2018/01/17
**/
public class BinarySearchTree<T extends Comparable<? super T>> {

/**
* 二叉树根节点
*/
private BinaryNode<T> root;

/**
* 静态内部节点类
*
* @param <T>
*/
private static class BinaryNode<T> {

private T element;
private BinaryNode<T> left;
private BinaryNode<T> right;

public BinaryNode() {
}

public BinaryNode(T element) {
this.element = element;
}

public BinaryNode(T element, BinaryNode<T> left, BinaryNode<T> right) {
this.element = element;
this.left = left;
this.right = right;
}
}

/**
* 清空二叉树
*/
public void makeEmpty() {
root = null;
}

/**
* 判断二叉树是否为空
*
* @return
*/
public boolean isEmpty() {
return root == null;
}

/**
* 查找元素element是否存在与二叉搜索树中
*
* @param element
* @return
*/
public boolean contains(T element) {
return contains(element, root);
}

/**
* 判断元素element是否存在于二叉查找树root中
*
* @param element
* @param root
* @return
*/
private boolean contains(T element, BinaryNode<T> root) {
if (root == null) {
return false;
}
int compareResult = element.compareTo(root.element);

if (compareResult > 0) {
return contains(element, root.right);
}

if (compareResult < 0) {
return contains(element, root.left);
}

return true;

}

/**
* 查找二叉查找树中最小的元素
*
* @return
*/
public T findMin() {
if (findMin(root) != null) {
return findMin(root).element;
}
return null;
}

/**
* 查找二叉搜索树中最小的节点
*
* @param root
* @return
*/
private BinaryNode<T> findMin(BinaryNode<T> root) {
if (root == null) {
return null;
}
if (root.left != null) {
return findMin(root.left);
}
return root.left;
}

/**
* 查找二叉树中的最大元素
*
* @return
*/
public T findMax() {
BinaryNode<T> maxNode = findMax(root);
if (maxNode != null) {
return maxNode.element;
}
return null;
}

/**
* 查找二叉查找树中的最大节点
*
* @param root
* @return
*/
private BinaryNode<T> findMax(BinaryNode<T> root) {
if (root == null) {
return null;
}
if (root.right != null) {
return findMax(root.right);
}
return root.right;
}

/**
* 插入元素element
*
* @param element
*/
public void insert(T element) {
root = insert(element, root);
}

/**
* 将元素插入到root二叉查找树中
*
* @param element
* @param root
* @return
*/
private BinaryNode<T> insert(T element, BinaryNode<T> root) {
if (root == null) {
return new BinaryNode<>(element);
}
int compareResult = element.compareTo(root.element);
if (compareResult > 0) {
root.right = insert(element, root.right);
} else if (compareResult < 0) {
root.left = insert(element, root.left);
}
return root;
}

/**
* 删除元素一个元素element
*
* @param element
*/
public void remove(T element) {

}

/**
* 在二叉查找树中删除元素element
*
* @param element
* @param root
* @return
*/
private BinaryNode<T> remove(T element, BinaryNode<T> root) {
if (root == null) {
return null;
}

int compareResult = element.compareTo(root.element);

if (compareResult > 0) {
root.right = remove(element, root.right);
} else if (compareResult < 0) {
root.left = remove(element, root.left);
}
// 被删除节点有两个子节点
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;
}
}