java 数据结构 二叉查找树的简单实现

什么是二叉查找树

二叉查找树是一种树结构。首先是二叉树。它表示每个节点最多有两个子节点，而二叉查找树，它还要求左子节点必须比右子节点小。



对于这个结构,我们以下几个操作的实现:

树中的元素必须能比较

这里的比较,我们不用equals和==,我们要判断它与节点中元素的大小关系,所以这里我们有2种实现方案:

1. 元素实现Comparable接口,重写它的compareTo方法

2. 在二叉树的构造方法中传入特定的Comparator比较器进行比较

/**
* 比较器
*/
private Comparator<T> comparator;

public BinarySearchTree() {
root = null;
comparator = null;
}

/**
* 带有指定比较器的构造方法
* @param comparator
*/
public BinarySearchTree(Comparator<T> comparator) {
root = null;
this.comparator = comparator;
}

/**
* 自己实现一个compare方法
* 如果在构造时传入了相应的比较器,则用传入比较器的compare方法
* 若没有传，则强转成comparable进行比较
*
* @param t1
* @param t2
* @return
*/
private int compare(T t1, T t2) {
/**
* 如果比较器不为null
*/
if (comparator != null) {
return comparator.compare(t1, t2);
}
return ((Comparable) t1).compareTo(t2);
}

insert操作

当执行插入操作时，思路就是比较插入元素和节点元素的大小,若插入元素大,则往节点右边走,相反则往节点左边走,最后当节点的左边或右边为null的时候,就把元素插入进去了.若碰到插入元素重复的情况则不管

public void insert(T t) {
root = insert(t, root);
}

private BinaryNode<T> insert(T t, BinaryNode binaryNode) {
if (binaryNode == null) {
BinaryNode node = new BinaryNode(t, null, null);
return node;
}
Object element = binaryNode.element;

int compare = compare(t, (T) element);

if (compare == -1) {
// 说明t 比 element 小
binaryNode.left = insert(t, binaryNode.left);
} else if (compare == 1) {
// 说明t 比 element 大
binaryNode.right = insert(t, binaryNode.right);
} else ;
/**
* 若t和element一样大则不做任何事情
*/

/**
* 把根返回
*/
return binaryNode;
}

contains操作

和insert操作基本一个思路,就是比较元素和节点元素大小来判断往左走还是往右走,若碰到元素和节点元素相等的情况则返回true，否则返回false

public boolean contains(T t) {
return contains(t, root);
}

private boolean contains(T t, BinaryNode binaryNode) {
if (binaryNode == null) {
return false;
}
Object element = binaryNode.element;

int compare = compare(t, (T) element);

if (compare == 1) {
return contains(t, binaryNode.right);
} else if (compare == -1) {
return contains(t, binaryNode.left);
} else {
return true;
}
}

findMin和findMax操作

很简单,findMin就是一直往左走，知道节点的左节点为null时,则该节点的元素最小,findMax则相反，这里我们findMax用递归实现,findMin用循环实现

public T findMin() {
BinaryNode min = findMin(root);
if (min != null) {
return (T) min.element;
}
return null;
}

public T findMax() {
BinaryNode max = findMax(root);
if (max != null) {
return (T) max.element;
}
return null;
}

private BinaryNode findMin(BinaryNode binaryNode) {
if (binaryNode != null) {
while (binaryNode.left != null) {
binaryNode = binaryNode.left;
}
}
return binaryNode;
}

private BinaryNode findMax(BinaryNode binaryNode) {
if (binaryNode == null) {
return null;
}
if(binaryNode.right != null) {
return findMax(binaryNode.right);
}
return binaryNode;
}

remove操作

这个比较麻烦,因为有几种情况:

删除的节点没有子节点。。。。这个比较简单,直接删除即可

删除的节点有一个子节点。。。。我们通过把要删除节点的父节点的链绕过该节点,在删除

删除的节点有两个子节点。。。这种情况就比较麻烦了,我们先拿到这个节点的右子节点,然后一直往左拿到最小的那个节点,用这个最小节点的数据代替我们要删除的节点,然后把这个最小的节点删除即可

public boolean remove(T t) {
BinaryNode remove = remove(t, root);
if (remove != null) {
return true;
}
return false;
}

private BinaryNode remove(T t, BinaryNode binaryNode) {
if (binaryNode == null) {
return binaryNode;
}
int compare = compare(t, (T) binaryNode.element);

if (compare == -1) {
binaryNode.left = remove(t, binaryNode.left);
} else if (compare == 1) {
binaryNode.right = remove(t, binaryNode.right);
} else if (binaryNode.left != null && binaryNode.right != null) {
/**
*这儿注释的三局代码,findMin会搜索一遍,remove又会搜索一遍,所以我们写一个特殊的removeMin方法来避免这个操作
*/
//            BinaryNode min = findMin(binaryNode.right);
//            binaryNode.element = min.element;
//            binaryNode.right = remove((T) min.element, binaryNode.right);
removeMin(binaryNode);
} else {
binaryNode = binaryNode.left == null ? binaryNode.right : binaryNode.left;
}
return binaryNode;
}

private void removeMin(BinaryNode binaryNode) {
if (binaryNode == null) {
return ;
}
BinaryNode node = binaryNode.right;
BinaryNode parentNode = null;

while (true) {
if(node.left != null) {
parentNode = node;
node = node.left;
} else {
Object element = node.element;
binaryNode.element = element;
parentNode.left = node.right;
break;
}
}
}

代码

package collection;

import java.util.Comparator;

/**
* Created by sunhan on 2018/1/14.
*/
public class BinarySearchTree<T> {

private static class BinaryNode<T> {

private BinaryNode<T> left;

private BinaryNode<T> right;

private T element;

public BinaryNode(T t) {
this(t, null, null);
}

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

/**
* 先序遍历
*/

public void suffix(){
midIterator(root);
}

private void suffixIterator(BinaryNode node){
System.out.println(node.element.toString());
if(node.left != null){
suffixIterator(node.left);
}
if(node.right != null){
suffixIterator(node.right);
}
}

/**
* 中序遍历
*/

public void mid(){
midIterator(root);
}

private void midIterator(BinaryNode node){
if(node.left != null){
midIterator(node.left);
}
System.out.println(node.element.toString());
if(node.right != null){
midIterator(node.right);
}
}

/**
* 后序遍历
*/

public void back(){
backIterator(root);
}

private void backIterator(BinaryNode node){
if(node.left != null){
backIterator(node.left);
}
if(node.right != null){
backIterator(node.right);
}
System.out.println(node.element.toString());
}

/**
* 根
*/
private BinaryNode<T> root;

/**
* 比较器
*/
private Comparator<T> comparator;

public BinarySearchTree() {
root = null;
comparator = null;
}

/**
* 带有指定比较器的构造方法
* @param comparator
*/
public BinarySearchTree(Comparator<T> comparator) {
root = null;
this.comparator = comparator;
}

/**
* 自己实现一个compare方法
* 如果在构造时传入了相应的比较器,则用传入比较器的compare方法
* 若没有传，则强转成comparable进行比较
*
* @param t1
* @param t2
* @return
*/
private int compare(T t1, T t2) {
/**
* 如果比较器不为null
*/
if (comparator != null) {
return comparator.compare(t1, t2);
}
return ((Comparable) t1).compareTo(t2);
}

public void insert(T t) {
root = insert(t, root);
}

private BinaryNode<T> insert(T t, BinaryNode binaryNode) {
if (binaryNode == null) {
BinaryNode node = new BinaryNode(t, null, null);
return node;
}
Object element = binaryNode.element;

int compare = compare(t, (T) element);

if (compare == -1) {
// 说明t 比 element 小
binaryNode.left = insert(t, binaryNode.left);
} else if (compare == 1) {
// 说明t 比 element 大
binaryNode.right = insert(t, binaryNode.right);
} else ;
/**
* 若t和element一样大则不做任何事情
*/

/**
* 把根返回
*/
return binaryNode;
}

public T findMin() {
BinaryNode min = findMin(root);
if (min != null) {
return (T) min.element;
}
return null;
}

public T findMax() {
BinaryNode max = findMax(root);
if (max != null) {
return (T) max.element;
}
return null;
}

private BinaryNode findMin(BinaryNode binaryNode) {
if (binaryNode != null) {
while (binaryNode.left != null) {
binaryNode = binaryNode.left;
}
}
return binaryNode;
}

private BinaryNode findMax(BinaryNode binaryNode) {
if (binaryNode == null) {
return null;
}
if(binaryNode.right != null) {
return findMax(binaryNode.right);
}
return binaryNode;
}

public boolean contains(T t) {
return contains(t, root);
}

private boolean contains(T t, BinaryNode binaryNode) {
if (binaryNode == null) {
return false;
}
Object element = binaryNode.element;

int compare = compare(t, (T) element);

if (compare == 1) {
return contains(t, binaryNode.right);
} else if (compare == -1) {
return contains(t, binaryNode.left);
} else {
return true;
}
}

public boolean remove(T t) {
BinaryNode remove = remove(t, root);
if (remove != null) {
return true;
}
return false;
}

private BinaryNode remove(T t, BinaryNode binaryNode) {
if (binaryNode == null) {
return binaryNode;
}
int compare = compare(t, (T) binaryNode.element);

if (compare == -1) {
binaryNode.left = remove(t, binaryNode.left);
} else if (compare == 1) {
binaryNode.right = remove(t, binaryNode.right);
} else if (binaryNode.left != null && binaryNode.right != null) {
//            BinaryNode min = findMin(binaryNode.right);
//            binaryNode.element = min.element;
//            binaryNode.right = remove((T) min.element, binaryNode.right);
removeMin(binaryNode);
} else {
binaryNode = binaryNode.left == null ? binaryNode.right : binaryNode.left;
}
return binaryNode;
}

private void removeMin(BinaryNode binaryNode) {
if (binaryNode == null) {
return ;
}
BinaryNode node = binaryNode.right;
BinaryNode parentNode = null;

while (true) {
if(node.left != null) {
parentNode = node;
node = node.left;
} else {
Object element = node.element;
binaryNode.element = element;
parentNode.left = node.right;
break;
}
}
}
}