二叉搜索树bst_二进制搜索树（BST）–搜索插入和删除

二叉搜索树bst

In this tutorial, we’ll be discussing the Binary Search Tree Data Structure. We’ll be implementing the functions to search, insert and remove values from a Binary Search Tree. We’ll implement these operations recursively as well as iteratively.

在本教程中，我们将讨论二进制搜索树数据结构。 我们将实现在Binary Search Tree中搜索，插入和删除值的功能。 我们将以递归方式和迭代方式实施这些操作。

二进制搜索树 (Binary Search Tree)

A Binary Search tree has the following property:

二叉搜索树具有以下属性：

• All nodes should be such that the left child is always less than the parent node.
  所有节点的左子节点应始终小于父节点。
• The right child is always greater than the parent node.
  正确的子节点始终大于父节点。

In the following sections, we’ll see how to search, insert and delete in a BST recursively as well as iteratively.

在以下各节中，我们将了解如何以递归和迭代方式在BST中搜索，插入和删除。

Let’s create our Binary Tree Data Structure first:

让我们首先创建我们的二叉树数据结构：

public class BinaryTree {

	public TreeNode root;

	public static class TreeNode {

		public TreeNode left;
		public TreeNode right;
		public Object data;

		public TreeNode(Object data) {
			this.data = data;
			left = right = null;
		}
	}
}

Note that the above implementation is not a binary search tree because there is no restriction in inserting elements to the tree.

注意，上述实现不是二叉搜索树，因为在树中插入元素没有限制。

BST递归搜索 (BST Search Recursively)

The following java program contains the function to search a value in a BST recursively.

以下Java程序包含用于在BST中递归搜索值的函数。

public class SearchInsertRemoveFromTree {

    public static void main(String[] args) {

	/**
	 *   Our Example Binary Search Tree
	 *       10
	 *     5    20
	 *   4  8  15 25
	 */

        BinaryTree tree = new BinaryTree();
        tree.root = new TreeNode(10);
        tree.root.left = new TreeNode(5);
        tree.root.right = new TreeNode(20);
        tree.root.left.left = new TreeNode(4);
        tree.root.left.right = new TreeNode(8);
        tree.root.right.left = new TreeNode(15);
        tree.root.right.right = new TreeNode(25);

        System.out.println("Search Value 2 is in tree? " + searchRecursively(tree.root, 2));
        System.out.println("Search Value 10 in tree? " + searchRecursively(tree.root, 10));
    }

    public static boolean searchRecursively(TreeNode root, int value) {


        if (root == null)
            return false;


        if ((int) root.data == value)
            return true;

        if (value < (int) root.data)
            return searchRecursively(root.left, value);

        else if (value > (int) root.data)
            return searchRecursively(root.right, value);


        return false;
    }
}

The output is:

输出为：

BST迭代搜索 (BST Search Iteratively)

To search iteratively, use the following method instead:

要迭代搜索，请改用以下方法：

public static boolean searchIteratively(TreeNode root, int value) {

        while (root != null) {
            if ((int) root.data == value)
                return true;

            if (value < (int) root.data)
                root = root.left;

            else
                root = root.right;
        }

        return false;
    }

Let's look at how to insert a new node in a Binary Search Tree.

让我们看一下如何在二进制搜索树中插入新节点。

BST递归插入 (BST Insertion Recursively)

public static TreeNode insertionRecursive(TreeNode root, int value) {

        if (root == null)
            return new TreeNode(value);

        if (value < (int) root.data) {
            root.left = insertionRecursive(root.left, value);
        } else if (value > (int) root.data) {
            root.right = insertionRecursive(root.right, value);
        }

        return root;

    }

public static void printInorderTraversal(TreeNode root) {
        if (root != null) {
            printInorderTraversal(root.left);
            System.out.print(root.data + " ");
            printInorderTraversal(root.right);
        }
    }

Call the above method in the main method:

在main方法中调用上述方法：

tree.root = insertionRecursive(tree.root, 24);
tree.root = insertionRecursive(tree.root, 2);
printInorderTraversal(tree.root);

The tree is printed in the form of inorder traversal.

该树以有序遍历的形式打印。

BST插入迭代 (BST Insertion Iterative)

To insert a Node iteratively in a BST tree, we will need to traverse the tree using two pointers.

要将节点迭代地插入BST树中，我们将需要使用两个指针遍历该树。

public static TreeNode insertionIterative(TreeNode root, int value) {

        TreeNode current, parent;

        TreeNode tempNode = new TreeNode(value);

        if (root == null) {
            root = tempNode;
            return root;
        } else {
            current = root;
        }

        while (true) {
            parent = current;

            if (value < (int) current.data) {
                current = current.left;
                if (current == null) {
                    parent.left = tempNode;
                    return root;
                }

            } else if (value > (int) current.data) {
                current = current.right;

                if (current == null) {
                    parent.right = tempNode;
                    return root;
                }
            }

        }
    }

BST递归删除元素 (BST Removing Element Recursively)

Removing an element from a BST is a little complex than searching and insertion since we must ensure that the BST property is conserved.

从BST中删除元素比搜索和插入要复杂一些，因为我们必须确保BST属性得到保留。

To delete a node we need first search it. Then we need to determine if that node has children or not.

要删除节点，我们需要先搜索它。 然后，我们需要确定该节点是否有子节点。

• If no children - Just delete.
  如果没有孩子 -请删除。
• If a single child - Copy that child to the node.
  如果是单个孩子 -将那个孩子复制到该节点。
• If two children - Determine the next highest element (inorder successor) in the right subtree. Replace the node to be removed with the inorder successor. Delete the inorder successor duplicate.
  如果有两个孩子 -确定右子树中的下一个最高元素（顺序后继）。 用顺序后继节点替换要删除的节点。 删除顺序的后继副本。

The inorder successor can be obtained by finding the minimum value in right child of the node.

可通过在节点的右子节点中找到最小值来获得有序后继者。

The following java program removes elements from a BST:

以下Java程序从BST中删除元素：

public static TreeNode deleteRecursively(TreeNode root, int value) {

        if (root == null)
            return root;

        if (value < (int) root.data) {
            root.left = deleteRecursively(root.left, value);
        } else if (value > (int) root.data) {
            root.right = deleteRecursively(root.right, value);
        } else {

            if (root.left == null) {
                return root.right;
            } else if (root.right == null)
                return root.left;

            root.data = inOrderSuccessor(root.right);
            root.right = deleteRecursively(root.right, (int) root.data);
        }

        return root;

    }

    public static int inOrderSuccessor(TreeNode root) {
        int minimum = (int) root.data;
        while (root.left != null) {
            minimum = (int) root.left.data;
            root = root.left;
        }
        return minimum;
    }

Call the above delete method in the main method:

在main方法中调用上述delete方法：

tree.root = deleteRecursively(tree.root, 4);
tree.root = deleteRecursively(tree.root, 20);
printInorderTraversal(tree.root);

The output is:
2 5 8 10 15 24 25

输出为：
2 5 8 10 15 24 25

Let's do the same iteratively.

让我们反复进行相同的操作。

BST迭代删除元素 (BST Removing Element Iteratively)

public static TreeNode deleteNodeIteratively(TreeNode root, int value) {
        TreeNode parent = null, current = root;
        boolean hasLeft = false;

        if (root == null)
            return root;

        while (current != null) {
            if ((int) current.data == value) {
                break;
            }

            parent = current;
            if (value < (int) current.data) {
                hasLeft = true;
                current = current.left;
            } else {
                hasLeft = false;
                current = current.right;
            }
        }


        if (parent == null) {
            return deleteNodeIteratively(current);
        }

        if (hasLeft) {
            parent.left = deleteNodeIteratively(current);
        } else {
            parent.right = deleteNodeIteratively(current);
        }

        return root;
    }

    private static TreeNode deleteNodeIteratively(TreeNode node) {

        if (node != null) {
            if (node.left == null && node.right == null) {
                return null;
            }

            if (node.left != null && node.right != null) {
                TreeNode inOrderSuccessor = deleteInOrderSuccessorDuplicate(node);
                node.data = inOrderSuccessor.data;
            } else if (node.left != null) {
                node = node.left;
            } else {
                node = node.right;
            }
        }

        return node;
    }

    private static TreeNode deleteInOrderSuccessorDuplicate(TreeNode node) {
        TreeNode parent = node;
        node = node.right;
        boolean rightChild = node.left == null;

        while (node.left != null) {
            parent = node;
            node = node.left;
        }

        if (rightChild) {
            parent.right = node.right;
        } else {
            parent.left = node.right;
        }

        node.right = null;
        return node;
    }

h is the height of the tree.
h是树的高度。

That brings an end to this tutorial.

这样就结束了本教程。

GitHub Repository. GitHub存储库中检出完整的代码以及更多DS和算法示例。

翻译自: https://www.journaldev.com/23086/binary-search-tree-bst-search-insert-remove

二叉搜索树bst