二进制树搜索算法java实现主函数

以下是一个简单的主函数，用于测试二进制树搜索算法的实现。

public static void main(String[] args) {
    BinarySearchTree tree = new BinarySearchTree();
    tree.insert(5);
    tree.insert(2);
    tree.insert(8);
    tree.insert(1);
    tree.insert(4);
    tree.insert(7);
    tree.insert(9);

    Node node1 = tree.search(4);
    System.out.println(node1.key); // 4

    Node node2 = tree.search(6);
    System.out.println(node2); // null
}

在上述代码中，我们先创建了一个二叉树，并插入了7个节点。然后分别查找了节点4和节点6，输出了它们的值。由于节点4存在于二叉树中，因此输出结果为4，而节点6不存在于二叉树中，因此输出结果为null。

相关问题

二进制树搜索算法java实现

以下是二进制树搜索算法的Java实现，包括二进制编码的生成、节点的插入和查找操作。

public class BinarySearchTree {
    private Node root;

    // 节点类
    private class Node {
        int key;
        Node left;
        Node right;

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

    // 生成二进制编码
    private String toBinaryString(int n) {
        StringBuilder sb = new StringBuilder();
        while (n > 0) {
            sb.append(n % 2);
            n /= 2;
        }
        return sb.reverse().toString();
    }

    // 插入节点
    public void insert(int key) {
        Node newNode = new Node(key);
        if (root == null) {
            root = newNode;
            return;
        }
        String keyStr = toBinaryString(key);
        Node currentNode = root;
        Node parentNode = null;
        while (currentNode != null) {
            parentNode = currentNode;
            if (keyStr.compareTo(toBinaryString(currentNode.key)) < 0) {
                currentNode = currentNode.left;
            } else {
                currentNode = currentNode.right;
            }
        }
        if (keyStr.compareTo(toBinaryString(parentNode.key)) < 0) {
            parentNode.left = newNode;
        } else {
            parentNode.right = newNode;
        }
    }

    // 查找节点
    public Node search(int key) {
        String keyStr = toBinaryString(key);
        Node currentNode = root;
        while (currentNode != null) {
            if (keyStr.compareTo(toBinaryString(currentNode.key)) == 0) {
                return currentNode;
            } else if (keyStr.compareTo(toBinaryString(currentNode.key)) < 0) {
                currentNode = currentNode.left;
            } else {
                currentNode = currentNode.right;
            }
        }
        return null;
    }
}

在上述代码中，toBinaryString函数用于将整数转换为二进制字符串，insert函数用于插入新节点，search函数用于查找节点。其中，插入和查找操作的时间复杂度均为O(log n)。

动态二进制树形搜索算法Java编程实现

以下是一个简单的Java代码实现动态二进制树形搜索算法：

class DynamicBinaryTree {
    private Node root;

    private class Node {
        private int data;
        private Node left;
        private Node right;

        public Node(int data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    }

    public DynamicBinaryTree() {
        root = null;
    }

    public void insert(int data) {
        if (root == null) {
            root = new Node(data);
            return;
        }

        Node current = root;
        while (true) {
            if (data < current.data) {
                if (current.left == null) {
                    current.left = new Node(data);
                    return;
                }
                current = current.left;
            } else {
                if (current.right == null) {
                    current.right = new Node(data);
                    return;
                }
                current = current.right;
            }
        }
    }

    public boolean search(int data) {
        Node current = root;
        while (current != null) {
            if (data == current.data) {
                return true;
            } else if (data < current.data) {
                current = current.left;
            } else {
                current = current.right;
            }
        }
        return false;
    }
}

在代码中，我们定义了一个 `Node` 类表示二叉树的节点，其中包含了数据、左子树和右子树的引用。我们还定义了一个 `DynamicBinaryTree` 类，其中包含了插入数据和搜索数据的方法。

在插入数据时，我们首先判断根节点是否为空，如果为空，则将该节点作为根节点插入。如果根节点不为空，则从根节点开始搜索，如果待插入数据小于当前节点的数据，则继续搜索其左子树，否则继续搜索其右子树，直到找到一个空节点为止，然后将该节点插入到对应的位置。

在搜索数据时，我们从根节点开始搜索，如果待查找数据等于当前节点的数据，则返回 true。否则，如果待查找数据小于当前节点的数据，则继续搜索其左子树，否则继续搜索其右子树，直到找到一个空节点为止，表示没有找到该数据，返回 false。