数据结构与算法分析（Java语言描述）（20）—— 二叉搜索树指定key的前驱、后继

前驱

---

// --------------------------------------------------------------------
    // 查找 key 的前驱

    public Key predecessor(Key key){

        // 在二叉搜索树中查找 key 对应的节点
        Node node = search(root, key);

        // 如果 key 对应的节点不存在，则 key 没有前驱，返回 null
        if (node == null)
            return null;

        // 如果 key 对应节点的左子树不为空，则返回左子树最大 key
        if (node.left != null)
            return maximum(node.left).key;

        // 否则，key 的前驱在从根节点到 key 的路径上，在这个路径上寻找到比 key 小的最大值
        // 即为 key 的前驱
        Node preNode = predecessorFromAncestor(root, key);
        return preNode == null ? null : preNode.key;
    }

    // 在以node为根的二叉搜索树中, 寻找key的祖先中,比key小的最大值所在节点, 递归算法
    // 算法调用前已保证key存在在以node为根的二叉树中
    private Node predecessorFromAncestor(Node node, Key key){
        if (key.compareTo(node.key) == 0)
            return null;
        Node maxNode;
        if (key.compareTo(node.key) < 0){
            // 如果当前节点 > key，则当前节点不可能是比 key 小的最大值
            // 向下搜索到的结果直接返回
            return predecessorFromAncestor(node.left, key);
        }else { // key > node.key
            // 如果当前节点 < key，则当前节点可能是比 key 小的最大值
            // 向下搜索结果存储到 maxNode 中
            maxNode = predecessorFromAncestor(node.right, key);
            if (maxNode != null)
                // maxNode 和当前节点 node 取最大值返回
                return maxNode.key.compareTo(node.key) > 0 ? maxNode: node;
            else
                // maxNode 为，返回 node
                return node;
        }
    }

---

后继

---

 // --------------------------------------------------------------------
    // 查找 key 的后继

    // 查找key的后继, 递归算法
    // 如果不存在key的后继(key不存在, 或者key是整棵二叉树中的最大值), 则返回 null
    public Key successor(Key key){
        Node node = search(root, key);

        // 如果key所在的节点不存在, 则key没有前驱, 返回 null
        if (node == null)
            return null;

        // 如果key所在的节点右子树不为空,则其右子树的最小值为key的后继
        if (node.right != null)
            return minimum(node.right).key;

        // 否则, key的后继在从根节点到key的路径上, 在这个路径上寻找到比key大的最小值, 即为key的后继
        Node sucNode = successorFromAncestor(root, key);
        return sucNode == null ? null : sucNode.key;
    }

    // 在以node为根的二叉搜索树中, 寻找key的祖先中,比key大的最小值所在节点, 递归算法
    // 算法调用前已保证key存在在以node为根的二叉树中
    private Node successorFromAncestor(Node node, Key key){
        if (key.compareTo(node.key) == 0){
            return null;
        }
        Node minNode = null;
        if (key.compareTo(node.key) > 0 ){
            // 如果当前节点小于key, 则当前节点不可能是比key大的最小值
            // 向下搜索到的结果直接返回
            return successorFromAncestor(node.right, key);
        }else { // key < node.key
            // 如果当前节点大于key, 则当前节点有可能是比key大的最小值
            // 向下搜索结果存储到minNode中
            minNode = successorFromAncestor(node.left, key);
            if (minNode != null)
                // minNode和当前节点node取最小值返回
                return minNode.key.compareTo(node.key) > 0 ? node : minNode;
            else
                // 如果minNode为空, 则当前节点即为结果
                return node;
        }
    }