（数据结构）二叉搜索树——java实现

本文参考文章：数据结构(十二)之二叉搜索树 - 简书

什么是二叉搜索树？

• 二叉搜索树是一颗二叉树，可以为空，如果不为空，满足以下性质：
• 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
• 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
• 任意节点的左，右子树也分别为二叉搜索树；
• 没有键值相等的节点。

 二叉搜索树的操作：

• insert(key)：向树中插入一个新的键。
• search(key)：在树中查找一个键，如果结点存在，则返回true；如果不存在，则返回false。
• inOrderTraverse：通过中序遍历方式遍历所有结点。
• preOrderTraverse：通过先序遍历方式遍历所有结点。
• postOrderTraverse：通过后序遍历方式遍历所有结点。
• min：返回树中最小的值/键。
• max：返回树中最大的值/键。
• remove(key)：从树中移除某个键。

 Java代码实现：

//二叉搜索树

public class BinarySearchTree {
    //节点内部类
    private class Node {
        private Node left;  //节点的左节点
        private int key;  //节点的键值
        private Node right;  //节点的右节点

        public Node(int key) {  //节点的构造函数
            this.left = null;
            this.key = key;
            this.right = null;
        }
    }

    //根节点
    private Node root = null;

    //添加节点
    public void insert(int key) {
        Node newnode = new Node(key);
        if (root == null) {   //判断根节点是否为空
            root = newnode;
        } else {
            insertnewnode(root, newnode);
        }
    }

    private void insertnewnode(Node node, Node newnode) {
        if (node.key > newnode.key) {
            if (node.left == null) {
                node.left = newnode;
            } else {
                insertnewnode(node.left, newnode);
            }
        } else {
            if (node.right == null) {
                node.right = newnode;
            } else {
                insertnewnode(node.right, newnode);
            }
        }
    }

    //先序遍历节点
    public void preOrderTraversal() {
        if (root != null) {
            preOrderTraversalNode(root);
        }
    }

    private void preOrderTraversalNode(Node node) {
        handler(node.key);  //打印节点值
        if (node.left != null) {
            preOrderTraversalNode(node.left); //迭代先序遍历左子树
        }
        if (node.right != null) {
            preOrderTraversalNode(node.right);  //迭代先序遍历右子树
        }
    }

    //中序遍历节点
    public void inOrderTraversal() {
        if (root != null) {
            inOrderTraversalNode(root);
        }
    }

    private void inOrderTraversalNode(Node node) {
        if (node.left != null) {
            inOrderTraversalNode(node.left);
        }
        handler(node.key);
        if (node.right != null) {
            inOrderTraversalNode(node.right);
        }
    }

    //后序遍历节点
    public void postOrderTraversal() {
        if (root != null) {
            postOrderTraversalNode(root);
        }
    }

    private void postOrderTraversalNode(Node node) {
        if (node.left != null) {
            postOrderTraversalNode(node.left);
        }
        if (node.right != null) {
            postOrderTraversalNode(node.right);
        }
        handler(node.key);
    }

    //遍历打印key值
    private void handler(int key) {
        System.out.print(key + " ");
    }

    //获取节点最大值
    public int max() {
        Node node = root;
        while (node.right != null) {  //找到树最右边的节点
            node = node.right;
        }
        return node.key;
    }

    //获取节点最小值
    public int min() {
        Node node = root;
        while (node.left != null) {  //找到树最左边的节点
            node = node.left;
        }
        return node.key;
    }

    //查找特定节点
    public boolean search(int key) {
        return searchNode(root, key);
    }

    private boolean searchNode(Node node, int key) {
        if (node == null) {
            return false;
        }
        if (node.key > key) {
            return searchNode(node.left, key);
        } else if (node.key < key) {
            return searchNode(node.right, key);
        } else {
            return true;
        }
    }

    //删除节点（三种情况）
    public boolean remove(int key) {
        Node current = root;  //临时变量，存储要删除的节点
        Node parent = root;  //临时变量，存储要删除节点的父节点
        boolean isLeftChild = true;  //临时变量，存储要删除节点是其父节点的左节点还是右节点
        //查找删除节点
        while (current.key != key) {
            parent = current;
            if (key < current.key) {
                isLeftChild = true;
                current = current.left;
            } else {
                isLeftChild = false;
                current = current.right;
            }
            if (current == null) {
                return false;
            }
        }
        //1.删除节点为叶节点，没有子节点
        if (current.left == null && current.right == null) {
            if (current == root) {
                root = null;
            } else if (isLeftChild) {
                parent.left = null;
            } else {
                parent.right = null;
            }
        }
        //2.删除节点只有一个节点
        //2.1只有一个右节点
        else if (current.left == null) {
            if (current == root) {
                root = current.right;
            } else if (isLeftChild) {
                parent.left = current.right;
            } else {
                parent.right = current.right;
            }
        }
        //2.2只有一个左节点
        else if (current.right == null) {
            if (current == root) {
                root = current.left;
            } else if (isLeftChild) {
                parent.left = current.left;
            } else {
                parent.right = current.left;
            }
        }
        //3.删除节点有两个节点
        else {
            Node successor = getSuccessor(current);
            if (current == root) {
                root = successor;
            } else if (isLeftChild) {
                parent.left = successor;
            } else {
                parent.right = successor;
            }
            //将后继节点的左节点指向删除节点的左节点
            successor.left = current.left;
        }
        return true;
    }

    //当要删除节点有两个节点时，就要从其子节点中找出前驱节点或者后继节点来替代它
    //查找删除节点的后继节点
    private Node getSuccessor(Node node) {
        Node successorparent = node;  //临时变量，存储后继节点的父节点
        Node successor = node;  //临时变量，存储后继节点
        Node current = node.right;  //临时变量，用来判断节点的左节点是否存在
        while (current != null) {
            successorparent = successor;
            successor = current;
            current = current.left;
        }
        //如果后继节点存在右节点，要将其父节点的左节点指向其右节点
        if (successor != node.right) {
            successorparent.left = successor.right;
            //将后继节点的右节点指向删除节点的右节点
            successor.right = node.right;
        }
        return successor;
    }
}