java实现二叉查找树

最新推荐文章于 2024-08-07 17:24:39 发布

子夜求知

最新推荐文章于 2024-08-07 17:24:39 发布

阅读量1k

点赞数 1

分类专栏：数据结构与算法 java 文章标签： java 数据结构二叉树

本文链接：https://blog.csdn.net/blue_x2/article/details/120681747

版权

java 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

数据结构与算法

5 篇文章 0 订阅

订阅专栏

二叉查找树性质

开始这篇文章之前，首先我们回顾一下链表和数组元素查找方式，链表和数组查找某个元素必须从头节点往后遍历依次查找元素。这样的查找效率非常的低，如果使用二叉查找树则可以大大提高查找效率，接下来我们看看二叉查找树的创建规则。

二叉查找树的性质和规则

首先我们来看看二叉查找树是什么：它或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。如下图就是一棵二叉查找树：

在这里插入图片描述

由于一个节点的左子树的值均小于节点的值，右子树的值均大于节点的值。所以我们在查找的时候，发现我们要查找的值大于当前节点的时候我们则到该节点的右子树继续查找，这样查找效率就大大的提高了。接下激动人心的时刻开始，我们来写代码来实现这个数据结构。

二叉查找树的创建

二叉查找树的节点类

根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们设计一个结点类来描述结点这个事物。

节点类API设计：

类名	Node<Key,Value>
构造方法	Node(Key key, Value value, Node left, Node right)：创建Node对象
成员变量	1.public Node left:记录左子结点 2.public Node right:记录右子结点 3.public Key key:存储键 4.public Value value:存储值

代码实现

private class Node<Key,Value>{
        //存储键
        public Key key;
        //存储值
        private Value value;
        //记录左子结点
        public Node left;
        //记录右子结点
        public Node right;
        public Node(Key key, Value value, Node left, Node right) {
        this.key = key;
        this.value = value;
            this.left = left;
        this.right = right;
	}
}

二叉查找树API设计

类名	BinaryTree,Value value>
构造方法	BinaryTree()：创建BinaryTree对象
成员变量	1.private Node root:记录根结点 2.private int N:记录树中元素的个数
成员方法	1. public void put(Key key,Value value):向树中插入一个键值对 2.private Node put(Node x, Key key, Value val)：给指定树x上，添加键一个键值对，并返回添加后的新树 3.public Value get(Key key):根据key，从树中找出对应的值 4.private Value get(Node x, Key key):从指定的树x中，找出key对应的值 5.public void delete(Key key):根据key，删除树中对应的键值对 6.private Node delete(Node x, Key key):删除指定树x上的键为key的键值对，并返回删除后的新树 7.public int size():获取树中元素的个数

二叉查找树实现

插入方法put实现思想：

如果当前树中没有任何一个结点，则直接把新结点当做根结点使用
如果当前树不为空，则从根结点开始：
1. 如果新结点的key小于当前结点的key，则继续找当前结点的左子结点；
2. 如果新结点的key大于当前结点的key，则继续找当前结点的右子结点；
3. 如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值即可。

过程如下：

只存贮第一个元素：8-刘八

在这里插入图片描述

存储第二个元素：7-田七

在这里插入图片描述

存储第三个元素：9-郑九

在这里插入图片描述

存储第四个元素：3-王五
存储第五个元素：9-如花(直接替换郑九)

在这里插入图片描述

查询方法get实现思想：

从根节点开始：

如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；
如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；
如果要查询的key等于当前结点的key，则树中返回当前结点的value。

删除方法delete实现思想：

找到被删除结点；
找到被删除结点右子树中的最小结点minNode
删除右子树中的最小结点
让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树
让被删除结点的父节点指向最小结点minNode

过程

删除元素10

在这里插入图片描述

找到被删除的元素的右子树中的最小节点
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h9Eqd8Jx-1633798665174)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20211010002012941.png)]$
被删除节点的父节点指向被删除节点右子树中的最小节点

代码：

//二叉树代码
public class BinaryTree<Key extends Comparable<Key>, Value> {
    //记录根结点
    private Node root;
    //记录树中元素的个数
    private int N;
    //获取树中元素的个数
    public int size() {
        return N;
    }
    //向树中添加元素key-value
    public void put(Key key, Value value) {
        root = put(root, key, value);
    }
    //向指定的树x中添加key-value,并返回添加元素后新的树
    private Node put(Node x, Key key, Value value) {
        if (x == null) {
            //个数+1
            N++;
            return new Node(key, value, null, null);
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            //新结点的key大于当前结点的key，继续找当前结点的右子结点
            x.right = put(x.right, key, value);
        } else if (cmp < 0) {
            //新结点的key小于当前结点的key，继续找当前结点的左子结点
            x.left = put(x.left, key, value);
        } else {
            //新结点的key等于当前结点的key，把当前结点的value进行替换
            x.value = value;
        }
        return x;
    }
    //查询树中指定key对应的value
    public Value get(Key key) {
        return get(root, key);
    }
    //从指定的树x中，查找key对应的值
    public Value get(Node x, Key key) {
        if (x == null) {
            return null;
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            //如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；
            return get(x.right, key);
        } else if (cmp < 0) {
            //如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；
            return get(x.left, key);
        } else {
            //如果要查询的key等于当前结点的key，则树中返回当前结点的value。
            return x.value;
        }
    }
    //删除树中key对应的value
    public void delete(Key key) {
        root = delete(root, key);
    }
    //删除指定树x中的key对应的value，并返回删除后的新树
    public Node delete(Node x, Key key) {
        if (x == null) {
            return null;
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            //新结点的key大于当前结点的key，继续找当前结点的右子结点
            x.right = delete(x.right, key);
        } else if (cmp < 0) {
            //新结点的key小于当前结点的key，继续找当前结点的左子结点
            x.left = delete(x.left, key);
        } else {
            //新结点的key等于当前结点的key,当前x就是要删除的结点
            //1.如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if (x.right == null) {
                return x.left;
            }
            //2.如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if (x.left == null) {
                return x.right;
            }
            //3.当前结点的左右子树都存在
            //3.1找到右子树中最小的结点
            Node minNode = x.right;
            while (minNode.left != null) {
                minNode = minNode.left;
            }
            //3.2删除右子树中最小的结点
            Node n = x.right;
            while (n.left != null) {
                if (n.left.left == null) {
                    n.left = null;
                } else {
                    n = n.left;
                }
            }
            //3.3让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树
            minNode.left = x.left;
            minNode.right = x.right;
            //3.4让被删除结点的父节点指向最小结点minNode
            x = minNode;
            //个数-1
            N--;
        }
        return x;
    }
    private class Node {
        //存储键
        public Key key;
        //存储值
        private Value value;
        //记录左子结点
        public Node left;
        //记录右子结点
        public Node right;
        public Node(Key key, Value value, Node left, Node right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
}
//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
        BinaryTree<Integer, String> bt = new BinaryTree<>();
        bt.put(4, "二哈");
        bt.put(1, "张三");
        bt.put(3, "李四");
        bt.put(5, "王五");
        System.out.println(bt.size());
        bt.put(1,"老三");
        System.out.println(bt.get(1));
        System.out.println(bt.size());
        bt.delete(1);
        System.out.println(bt.size());
    }
}

二叉查找树其他便捷方法

查找二叉树中最小的键

在某些情况下，我们需要查找出树中存储所有元素的键的最小值，比如我们的树中存储的是学生的排名和姓名数据，那么需要查找出排名最低是多少名？这里我们设计如下两个方法来完成：

public Key min()	找出树中最小的键
private Node min(Node x)	找出指定树x中，最小键所在的结点

//找出整个树中最小的键
public Key min(){
	return min(root).key;
}
//找出指定树x中最小的键所在的结点
private Node min(Node x){
    if (x.left!=null){
    return min(x.left);
    }else{
    return x;
    }
}

查找二叉树中最大的键

在某些情况下，我们需要查找出树中存储所有元素的键的最大值，比如比如我们的树中存储的是学生的成绩和学生的姓名，那么需要查找出最高的分数是多少？这里我们同样设计两个方法来完成：

public Key max()	找出树中最大的键
public Node max(Node x)	找出指定树x中，最大键所在的结点

//找出整个树中最大的键
public Key max(){
    return max(root).key;
}
//找出指定树x中最大键所在的结点
public Node max(Node x){
    if (x.right!=null){
    return max(x.right);
    }else{
    return x;
    }
}

二叉树的基础遍历

很多情况下，我们可能需要像遍历数组数组一样，遍历树，从而拿出树中存储的每一个元素，由于树状结构和线性结构不一样，它没有办法从头开始依次向后遍历，所以存在如何遍历，也就是按照什么样的搜索路径进行遍历的问题。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wKuCjQFc-1633798665175)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20211010003213264.png)]$

我们把树简单的画作上图中的样子，由一个根节点、一个左子树、一个右子树组成，那么按照根节点什么时候被访问，我们可以把二叉树的遍历分为以下三种方式：

前序遍历；先访问根结点，然后再访问左子树，最后访问右子树
中序遍历；先访问左子树，中间访问根节点，最后访问右子树
后序遍历；先访问左子树，再访问右子树，最后访问根节点

如果我们分别对下面的树使用三种遍历方式进行遍历，得到的结果如下

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wFfBMQzN-1633798665176)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20211010003058303.png)]$

前序遍历

方法	功能
private void preErgodic(Node x,Queue keys)	使用前序遍历，把指定树x中的所有键放入到keys队列中
public Queue preErgodic()	使用前序遍历，获取整个树中的所有键

实现步骤：

把当前结点的key放入到队列中;
找到当前结点的左子树，如果不为空，递归遍历左子树
找到当前结点的右子树，如果不为空，递归遍历右子树

代码

//使用前序遍历，获取整个树中的所有键
public Queue<Key> preErgodic(){
    Queue<Key> keys = new Queue<>();
    preErgodic(root,keys);
    return keys;
}
//使用前序遍历，把指定树x中的所有键放入到keys队列中
private void preErgodic(Node x,Queue<Key> keys){
    if (x==null){
    return;
}
//1.把当前结点的key放入到队列中;
keys.enqueue(x.key);
//2.找到当前结点的左子树，如果不为空，递归遍历左子树
if (x.left!=null){
    preErgodic(x.left,keys);
}
//3.找到当前结点的右子树，如果不为空，递归遍历右子树
if (x.right!=null){
    preErgodic(x.right,keys);
}
}
//测试代码
public class Test {
	public static void main(String[] args) throws Exception {
        BinaryTree<String, String> bt = new BinaryTree<>();
        bt.put("E", "5");
        bt.put("B", "2");
        bt.put("G", "7");
        bt.put("A", "1");
        bt.put("D", "4");
        bt.put("F", "6");
        bt.put("H", "8");
        bt.put("C", "3");
        Queue<String> queue = bt.preErgodic();
        for (String key : queue) {
            System.out.println(key+"="+bt.get(key));
        }
    }
}

中序遍历

方法	功能
public Queue midErgodic()	使用中序遍历，获取整个树中的所有键
private void midErgodic(Node x,Queue keys)	使用中序遍历，把指定树x中的所有键放入到keys队列中

实现步骤：

找到当前结点的左子树，如果不为空，递归遍历左子树
把当前结点的key放入到队列中;
找到当前结点的右子树，如果不为空，递归遍历右子树

代码

//使用中序遍历，获取整个树中的所有键
public Queue<Key> midErgodic(){
    Queue<Key> keys = new Queue<>();
    midErgodic(root,keys);
    return keys;
}
//使用中序遍历，把指定树x中的所有键放入到keys队列中
private void midErgodic(Node x,Queue<Key> keys){
    if (x==null){
    	return;
    }
    //1.找到当前结点的左子树，如果不为空，递归遍历左子树
    if (x.left!=null){
    	midErgodic(x.left,keys);
	}
    //2.把当前结点的key放入到队列中;
    keys.enqueue(x.key);
    //3.找到当前结点的右子树，如果不为空，递归遍历右子树
    if (x.right!=null){
        midErgodic(x.right,keys);
    }
}
//测试代码
public class Test {
        public static void main(String[] args) throws Exception {
        BinaryTree<String, String> bt = new BinaryTree<>();
        bt.put("E", "5");
        bt.put("B", "2");
        bt.put("G", "7");
        bt.put("A", "1");
        bt.put("D", "4");
        bt.put("F", "6");
        bt.put("H", "8");
        bt.put("C", "3");
        Queue<String> queue = bt.midErgodic();
        for (String key : queue) {
        	System.out.println(key+"="+bt.get(key));
        }
    }
}

后序遍历

方法	功能
public Queue afterErgodic()	使用后序遍历，获取整个树中的所有键
private void afterErgodic(Node x,Queue keys)	使用后序遍历，把指定树x中的所有键放入到keys队列中

实现步骤：

找到当前结点的左子树，如果不为空，递归遍历左子树
找到当前结点的右子树，如果不为空，递归遍历右子树
把当前结点的key放入到队列中;

代码

//使用后序遍历，获取整个树中的所有键
public Queue<Key> afterErgodic(){
Queue<Key> keys = new Queue<>();
afterErgodic(root,keys);
	return keys;
}
//使用后序遍历，把指定树x中的所有键放入到keys队列中
private void afterErgodic(Node x,Queue<Key> keys){
if (x==null){
	return;
}
//1.找到当前结点的左子树，如果不为空，递归遍历左子树
if (x.left!=null){
	afterErgodic(x.left,keys);
}
//2.找到当前结点的右子树，如果不为空，递归遍历右子树
if (x.right!=null){
	afterErgodic(x.right,keys);
}
//3.把当前结点的key放入到队列中;
keys.enqueue(x.key);
}
//测试代码
public class Test {
        public static void main(String[] args) throws Exception {
        BinaryTree<String, String> bt = new BinaryTree<>();
        bt.put("E", "5");
        bt.put("B", "2");
        bt.put("G", "7");
        bt.put("A", "1");
        bt.put("D", "4");
        bt.put("F", "6");
        bt.put("H", "8");
        bt.put("C", "3");
        Queue<String> queue = bt.afterErgodic();
        for (String key : queue) {
        	System.out.println(key+"="+bt.get(key));
        }
    }
}