脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → java二分查找树

Java实现二分查找树及其相关操作

 更新时间：2021年07月26日 14:34:25   作者：胡不慌  
二分查找树是一种有组织的二叉树。我们可以通过链接节点表示这样一棵树，二分查找树（Binary Search Tree）的基本操作有搜索、求最大值、求最小值、求前驱、求后继、插入及删除，对java二分查找树相关知识感兴趣的朋友一起看看吧

二分查找树（Binary Search Tree）的基本操作有搜索、求最大值、求最小值、求前驱、求后继、插入及删除。

对二分查找树的进行基本操作所花费的时间与树的高度成比例。例如有n个节点的完全二叉树，对它进行的基本操作的时间复杂度为O(logn)。然而，如果树是一个有n个节点的线性的链，则在这种情况下的时间复杂度为O(n)。

1、什么是二分查找树

二分查找树是一种有组织的二叉树。我们可以通过链接节点表示这样一棵树。每个节点包含键（key），数据（data），左子节点（left），右子节点（right），父节点（parent）这五种属性。

如果一个节点没有父节点或某个子结点，则其对应的属性的值为null。

创建一个Node.java文件，用如下代码表示节点：

public class Node {
    public int key;
    public int data;
    public Node left;
    public Node right;
    public Node parent;
    
    public Node(){}
    
    public Node(int key) {
        this.key = key;
    }
}

创建一个BinarySearchTree.java文件，用如下代码表示二分查找树：

public class BinarySearchTree {
    public Node root;
}

接下来，会逐步补充代码。

对于存储在二分查找树中的键，必须满足下面这个条件（二分查找树特点）：

对于二叉树中的任一节点n，如果left是n左子树中的任何一个节点，有left.key <= n.key；如果right是n右子树中的任一节点，则有n.key<=right.key。

如果我们中序遍历二分查找树，能升序打印出所有的键（key）。

可在BinarySearchTree.java文件中加上如下代码实现中序遍历：

private void innerWalk(Node node) {
        if(node != null) {
            innerWalk(node.left);
            System.out.print(node.key + " ");
            innerWalk(node.right);
        }
    }

    public void innerWalk() {
        this.innerWalk(this.root);
        System.out.println();
    }

2、查询二分查找树

2.1、搜索

在二分查找树中搜索键为key的结点，如果找到，则返回该结点，否则，返回null。可利用二分查找树的特性来查找。

可在BinarySearchTree.java文件中加上如下代码实现搜索：

public Node search(int key) {
        Node pointer = this.root;
        while (pointer != null && pointer.key != key) {
            pointer = key < pointer.key ? pointer.left : pointer.right;
        }
        return pointer;
    }

2.2、最小值与最大值

求键最小的节点，可根据二叉树的特点，从根结点开始，遍历跟踪其左子节点，直到最后一个。

可在Node.java文件中加上如下代码实现：

 public Node minimum() {
        Node pointer = this;
        while(pointer.left != null){
            pointer = pointer.left;
        }
        return pointer;
    }

在BinarySearchTree.java文件中加上如下代码：

public Node minimum() {
        return this.root.minimum();
    }

求键最大的节点，可根据二叉树的特点，从根结点开始，遍历跟踪其右子节点，直到最后一个。

可在Node.java文件中加上如下代码实现：

 public Node maximum() {
        Node pointer = this;
        while(pointer.right != null) {
            pointer = pointer.right;
        }
        return pointer;
    }

在BinarySearchTree.java文件中加上如下代码：

public Node minimum() {
        return this.root.maximum();
    }

2.3、前驱与后继

给定一个二分查找树中的节点，有时我们需要发现它在树中所有结点按键升序排序的情况下的直接后继（后面第一个）。

如果树中所有的键是不同的，结点n的直接后继是大于n.key的最小结点。

如果该结点有右节点，则其直接后继是其右子树键最小的那个结点。如果该结点则判断该结点是其父节点的左子节点还是其右子节点。

如果是左子节点，则返回其父节点。如果是右子节点，判断其父节点的其父节点的父节点的左子节点还是右子节点，以此类推。

如果找不到，则返回null。

可在Node.java文件中加上如下实现代码：

public Node successor() {
        Node pointer = this;
        if (pointer.right != null)
            return pointer.right.minimum();
        Node parentPointer = pointer.parent;
        while (parentPointer != null && parentPointer.right == pointer) {
            pointer = parentPointer;
            parentPointer = parentPointer.parent;
        }
        return pointer;
    }

一个节点的直接前继是指树中所有结点按键升序排序的情况下，该节点的前面第一个。求直接前继的与求直接后继是对称的。

可在Node.java文件中加上如下实现代码：

 public Node predecessor() {
        Node pointer = this;
        if (pointer.left != null)
            return pointer.left.maximum();
        Node parentPointer = pointer.parent;
        while (parentPointer != null && parentPointer.left == pointer) {
            pointer = parentPointer;
            parentPointer = parentPointer.parent;
        }
        return pointer;
    }

3、插入与删除

插入与删除会导致二分查找树发生改变，但必须保持其特点。

3.1、插入

在树中找到一个键（key）最接近要插入结点键（key）的结点，且有可以插入的位置，然后插入合适的位置。

可在BinarySearchTree.java文件中加上如下实现代码：

 public void insert(Node node) {
        Node pointer = this.root;
        Node parentPointer = null;
        while (pointer != null) {
            parentPointer = pointer;
            pointer = node.key < pointer.key ? pointer.left : pointer.right;
        }
        node.parent = parentPointer;
        if (parentPointer == null)
            this.root = node;
        else if (node.key < parentPointer.key) {
            parentPointer.left = node;
        } else {
            parentPointer.right = node;
        }
    }

3.2、删除

删除节点后，我门要保持二分查找树的特点。

如果要删除节点没有任何子节点，直接可以删除它，不用做任何处理。

如果要删除节点只有一个左子树，可以用左子树的根节点代替要删除节点，也可以用左子树中键（key）最大的节点来代替要删除节点。

如果要删除结点只有一个右子树，可以用右子树的根节点代替要删除节点，也可以用右子树中键（key）最小的结点来代替要删除结点。

如果要删除结点既有左子树，又有右子树，可以用左子树中键（key）最大的结点代替要删除结点，也可以用右子树中键最小的结点代替要删除结点。

假设要从二分查找树tree中删除节点node，一种删除方法的具体步骤如下：

  • 如果node没有左子节点，然后我们可以用node的右子节node.right点代替node，node.right可能是或可能不是null。
  • 如果node只有左子节点node.left，则我们用node.left代替node。
  • 如果node有左子节点node.left和右子节点node.right。我么要发现node的直接后继s（node右子树中键最小的结点，它没有左子节点），s在node右子树中，然后用s代替node。这里要考虑下面两种情况：

如果s是node的右子节点，可以用s代替node。
否则，用s的右子节点代替s，然后再用s代替node。

由于我们需要在二分查找树中替换子树的方法，可以先写一个替换子树的方法。

可在BinarySearchTree.java文件中加上如下实现代码：

/**
     * 用子树node2代替代替子树node1
     * 
     * @param node1
     * @param node2
     */
    private void transplant(Node node1, Node node2) {
        if (node1.parent == null) {
            this.root = node2;
        } else if (node1.parent.left == node1) {
            node1.parent.left = node2;
        } else {
            node1.parent.right = node2;
        }

        if (node2 != null)
            node2.parent = node1.parent;
        node1.parent = null;
    }

接下来解释删除节点操作的代码实现。

可在BinarySearchTree.java文件中加上如下实现代码：

 public void delete(Node node) {
        if (node.left == null) {
            this.transplant(node, node.right);
        } else if (node.right == null) {
            this.transplant(node, node.left);
        } else {
            Node successor = node.successor();
            if (successor.parent != node) {
                this.transplant(successor, successor.right);
                successor.right = node.right;
                successor.right.parent = successor;
            }
            this.transplant(node, successor);
            successor.left = node.left;
            successor.left.parent = successor;
        }
    }

4、完整代码

Node.java文件

public class Node {
    public int key;
    public int data;
    public Node left;
    public Node right;
    public Node parent;

    public Node() {
    }

    public Node(int key) {
        this.key = key;
    }

    public Node minimum() {
        Node pointer = this;
        while (pointer.left != null)
            pointer = pointer.left;
        return pointer;
    }

    public Node maximum() {
        Node pointer = this;
        while (pointer.right != null)
            pointer = pointer.right;
        return pointer;
    }

    public Node successor() {
        Node pointer = this;
        if (pointer.right != null)
            return pointer.right.minimum();
        Node parentPointer = pointer.parent;
        while (parentPointer != null && parentPointer.right == pointer) {
            pointer = parentPointer;
            parentPointer = parentPointer.parent;
        }
        return pointer;
    }

    public Node predecessor() {
        Node pointer = this;
        if (pointer.left != null)
            return pointer.left.maximum();
        Node parentPointer = pointer.parent;
        while (parentPointer != null && parentPointer.left == pointer) {
            pointer = parentPointer;
            parentPointer = parentPointer.parent;
        }
        return pointer;
    }
}

BinarySearchTree.java文件

public class BinarySearchTree {
    public Node root;

    private void innerWalk(Node node) {
        if (node != null) {
            innerWalk(node.left);
            System.out.print(node.key + " ");
            innerWalk(node.right);
        }
    }

    public void innerWalk() {
        this.innerWalk(this.root);
        System.out.println();
    }

    public Node search(int key) {
        Node pointer = this.root;
        while (pointer != null && pointer.key != key) {
            pointer = key < pointer.key ? pointer.left : pointer.right;
        }
        return pointer;
    }

    public Node minimum() {
        return this.root.minimum();
    }

    public Node maximum() {
        return this.root.maximum();
    }

    public void insert(Node node) {
        Node pointer = this.root;
        Node parentPointer = null;
        while (pointer != null) {
            parentPointer = pointer;
            pointer = node.key < pointer.key ? pointer.left : pointer.right;
        }
        node.parent = parentPointer;
        if (parentPointer == null)
            this.root = node;
        else if (node.key < parentPointer.key) {
            parentPointer.left = node;
        } else {
            parentPointer.right = node;
        }
    }

    /**
     * 用子树node2代替代替子树node1
     * 
     * @param node1
     * @param node2
     */
    private void transplant(Node node1, Node node2) {
        if (node1.parent == null) {
            this.root = node2;
        } else if (node1.parent.left == node1) {
            node1.parent.left = node2;
        } else {
            node1.parent.right = node2;
        }

        if (node2 != null)
            node2.parent = node1.parent;
        node1.parent = null;
    }

    public void delete(Node node) {
        if (node.left == null) {
            this.transplant(node, node.right);
        } else if (node.right == null) {
            this.transplant(node, node.left);
        } else {
            Node successor = node.successor();
            if (successor.parent != node) {
                this.transplant(successor, successor.right);
                successor.right = node.right;
                successor.right.parent = successor;
            }
            this.transplant(node, successor);
            successor.left = node.left;
            successor.left.parent = successor;
        }
    }
}

5、演示

演示代码：

public class Test01 {
    public static void main(String[] args) {
        Node n1 = new Node(1);
        Node n2 = new Node(2);
        Node n3 = new Node(3);
        Node n4 = new Node(4);
        Node n5 = new Node(5);

        BinarySearchTree bst = new BinarySearchTree();
        bst.insert(n3);
        bst.insert(n4);
        bst.insert(n2);
        bst.insert(n1);
        bst.insert(n5);

        System.out.println("bst.minimum().key: " + bst.minimum().key);
        System.out.println("bst.maximum().key: " + bst.maximum().key);
        System.out.println("n3.successor().key: " + n3.successor().key);
        System.out.println("n3.predecessor().key: " + n3.predecessor().key);
        System.out.println("bst.search(4).key: " + bst.search(4).key);

        System.out.print("tree: ");
        bst.innerWalk();
        System.out.print("delete n3: ");
        bst.delete(n3);
        bst.innerWalk();
        System.out.print("delete n2: ");
        bst.delete(n2);
        bst.innerWalk();
        System.out.print("delete n1: ");
        bst.delete(n1);
        bst.innerWalk();
        System.out.print("delete n4: ");
        bst.delete(n4);
        bst.innerWalk();
        System.out.print("delete n5: ");
        bst.delete(n5);
        bst.innerWalk();
    }
}

结果：

bst.minimum().key: 1
bst.maximum().key: 5
n3.successor().key: 4
n3.predecessor().key: 2
bst.search(4).key: 4
tree: 1 2 3 4 5
delete n3: 1 2 4 5
delete n2: 1 4 5
delete n1: 4 5
delete n4: 5
delete n5:

到此这篇关于Java实现二分查找树及其相关操作的文章就介绍到这了,更多相关java二分查找树内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • springboot-mybatis/JPA流式查询的多种实现方式

    springboot-mybatis/JPA流式查询的多种实现方式

    这篇文章主要介绍了springboot-mybatis/JPA流式查询,本文给大家分享三种方式，每种方式结合示例代码给大家讲解的非常详细，需要的朋友可以参考下
    2022-12-12
  • PowerMockito的基本使用解析

    PowerMockito的基本使用解析

    这篇文章主要介绍了PowerMockito的基本使用，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-07-07
  • MyBatis的 config.xml标签

    MyBatis的 config.xml标签

    这篇文章主要介绍了MyBatis的 config.xml标签的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下
    2016-12-12
  • 侦听消息队列的Message Listener类示例详解

    侦听消息队列的Message Listener类示例详解

    Spring AMQP 是基于 Spring 框架的AMQP消息解决方案,提供模板化的发送和接收消息的抽象层,提供基于消息驱动的 POJO的消息监听等,简化了我们对于RabbitMQ相关程序的开发,本文给大家介绍侦听消息队列的Message Listener类,感兴趣的朋友一起看看吧
    2023-12-12
  • Spring Cloud Gateway编码实现任意地址跳转的示例

    Spring Cloud Gateway编码实现任意地址跳转的示例

    本文主要介绍了Spring Cloud Gateway编码实现任意地址跳转的示例，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-12-12
  • 使用自定义Json注解实现输出日志字段脱敏

    使用自定义Json注解实现输出日志字段脱敏

    这篇文章主要介绍了使用自定义Json注解实现输出日志字段脱敏，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-12-12
  • Java Quartz触发器CronTriggerBean配置用法详解

    Java Quartz触发器CronTriggerBean配置用法详解

    这篇文章主要介绍了Java Quartz触发器CronTriggerBean配置用法详解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-08-08
  • springboot项目拦截前端请求中的特殊字符串(解决方案)

    springboot项目拦截前端请求中的特殊字符串(解决方案)

    springboot项目中,需要对前端请求数据进行过滤,拦截特殊字符,本文通过实例代码给大家分享完美解决方案,感兴趣的朋友一起看看吧
    2023-10-10
  • Maven发布Jar包中文乱码解决方法

    Maven发布Jar包中文乱码解决方法

    这篇文章主要介绍了Maven发布Jar包中文乱码解决方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-03-03
  • 解决spring boot网关gateway导致的坑,无法下载文件问题

    解决spring boot网关gateway导致的坑,无法下载文件问题

    这篇文章主要介绍了解决spring boot网关gateway导致的坑，无法下载文件的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-07-07

最新评论