二叉查找树详解-java代码实现

最新推荐文章于 2023-04-03 17:21:52 发布

今天成为大神了吗

最新推荐文章于 2023-04-03 17:21:52 发布

阅读量450

点赞数

分类专栏：数据结构树文章标签：数据结构算法树堆

原文链接：http://blog.jobbole.com/79305/

版权

数据结构同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

树

2 篇文章 0 订阅

订阅专栏

转自：伯乐在线http://blog.jobbole.com/79305/

本文更改部分代码，以及对部分逻辑进行梳理总结。

二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
任意节点的左、右子树也分别为二叉查找树。
没有键值相等的节点（no duplicate nodes）。

如下图，这个是普通的二叉树：

在此基础上，加上节点之间的大小关系，就是二叉查找树：

在实现中，我们需要定义一个内部类Node，它包含两个分别指向左右节点的Node，一个用于排序的Key，以及该节点包含的值Value，还有一个记录该节点及所有子节点个数的值Number。

private static class BinaryNode<T> {
    T data;
    BinaryNode<T> left;
    BinaryNode<T> right;
    public BinaryNode(T data) {
        this(data, null, null);
    }
    public BinaryNode(T data, BinaryNode<T> left, BinaryNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}

查找

查找操作和二分查找类似，将key和节点的key比较，如果小于，那么就在Left Node节点查找,如果大于，则在Right Node节点查找，如果相等，直接返回Value。

该方法实现有迭代和递归两种。递归的方式实现如下：

public boolean contains(T data) {
    return contains(data, root);
}
private boolean contains(T data, BinaryNode<T> node) {
    if (node == null) {
        return false;
    }
    int compareResult = data.compareTo(node.data);
    if (compareResult < 0) {
        return contains(data, node.left);
    } else if (compareResult > 0) {
        return contains(data, node.right);
    } else {
        return true;
    }
}

插入

插入和查找类似，首先查找有没有和key相同的，如果有，更新；如果没有找到，那么创建新的节点。并更新每个节点的Number值，代码实现如下：

public void insert(T data) {
    root = insert(data, root);
}
private BinaryNode<T> insert(T data, BinaryNode<T> node) {
    if(node==null){
        return new BinaryNode(data, null, null);
    }
    int compareResult=data.compareTo(node.data);
    if(compareResult<0)
        node.left=insert(data, node.left);
    else if(compareResult>0)
        node.right=insert(data,node.right);
    else
        ;
    return node;
}

插入操作图示如下：

下面是插入动画效果：

随机插入形成树的动画如下，可以看到，插入的时候树还是能够保持近似平衡状态：

最大最小值

如下图可以看出，二叉查找树的最大最小值是有规律的：

从图中可以看出，二叉查找树中，最左和最右节点即为最小值和最大值，所以我们只需迭代调用即可。

public T findMin() throws Exception {
    //isEmpty() :judge whether node is null
    if (isEmpty())
        throw new Exception();
    return findMin(root).data;
}
public T findMax() throws Exception {
    if (isEmpty())
        throw new Exception();
    return findMax(root).data;
}
//递归实现
private BinaryNode<T> findMin(BinaryNode<T> node) {
    if (node == null)
        return null;
    else if (node.left == null)
        return node;
    else
        return findMin(node.left);
    }
//迭代实现
private BinaryNode<T> findMax(BinaryNode<T> node) {
    if (node != null) {
        while (node.right != null) {
            node = node.right;
        }
    }
    return node;
}

Floor和Ceiling

查找Floor(key)的值就是所有<=key的最大值，相反查找Ceiling的值就是所有>=key的最小值，下图是Floor函数的查找示意图：

以查找Floor为例，我们首先将key和root元素比较，如果key比root的date小，则floor值一定在左子树上；如果比root的 key大，则有可能在右子树上，当且仅当其右子树有一个节点的key值要小于等于该key；如果和root的key相等，则floor值就是key。根据以上分析，Floor方法的代码如下，Ceiling方法的代码类似，只需要把符号换一下即可：

public T Floor(T key)
{
    Node x = Floor(root, key);
    if (x != null) return x.Key;
    else return default(TKey);
}

private Node Floor(Node x, T key)
{
    if (x == null) return null;
    int cmp = key.CompareTo(x.date);
    if (cmp == 0) return x;
    if (cmp < 0) return Floor(x.Left, key);
    else
    {
        Node right = Floor(x.Right, key);
        if (right == null) return x;
        else return right;
    }
}

else部分业务逻辑梳理

当key值比当前节点的data值小，floor包含的值肯定在左节点上，不过多赘述。当key值比data值大的时候，就会存在两种情况，一是刚好该节点就是分界点，该节点x以及其子节点就是我们想要的全部结果；二是该节点也是floor包含的字节点之一，我们需要继续遍历右节点找到目标分界点，所以就需要继续递归。

情况一：所有的右节点都不存在比key小的data值，递归返回null；

情况二：存在真正的分界点，递归返回真正分界点节点node；
else
    {
        Node right = Floor(x.Right, key);
        if (right == null) return x;
        else return right;
    }

删除

删除元素操作在二叉树的操作中应该是比较复杂的。首先来看下比较简单的删除最大最小值得方法。以删除最小值为例，我们首先找到最小值，及最左边左子树为空的节点，然后返回其右子树作为新的左子树。操作示意图如下：

代码实现如下：

删除最大值也是类似。

现在来分析一般情况，假定我们要删除指定key的某一个节点。这个问题的难点在于：删除最大最小值的操作，删除的节点只有1个子节点或者没有子节点，这样比较简单。但是如果删除任意节点，就有可能出现删除的节点有0个，1 个，2个子节点的情况，现在来逐一分析。

当删除的节点没有子节点时，直接将该父节点指向该节点的link设置为null。

当删除的节点只有1个子节点时，将该自己点替换为要删除的节点即可。

当删除的节点有2个子节点时，问题就变复杂了。

假设我们删除的节点t具有两个子节点。因为t具有右子节点，所以我们需要找到其右子节点中的最小节点，替换t节点的位置。这里有四个步骤：

保存待删除的节点到临时变量t
将t的右节点的最小节点min(t.right)保存到临时节点x
将x的右节点设置为deleteMin(t.right)，该右节点是删除后，所有比x.data最大的节点。
将x的左节点设置为t的左节点。

整个过程如下图：

对应代码如下：

public void remove(T data) {
    root = remove(data, root);
}
private BinaryNode<T> remove(T data, BinaryNode<T> node) {
    if(node==null)
        return node;
    int compareRresult=data.compareTo(node.data);
    //查找节点
    if(compareRresult<0)
        node.left=remove(data, node.left);
    else if(compareRresult>0)
        node.right=remove(data, node.right);
    //找到节点进行处理
    else if(node.left!=null&&node.right!=null){
        //找到右节点的最小节点
        node.data=findMin(node.right).data;
        //移除右节点的最小节点
        node.right=remove(node.data, node.right);
    }else
        //待删除节点，不存在左节点时，直接将待删除节点置为左节点
        node=(node.left!=null)?node.left:node.right;
    return node;
}