【数据结构与算法 | 二叉树篇】二叉搜索树

1. 前言

数据结构好久没看了，代码感觉都有点生疏了。

二叉搜索树前提是二叉树，每个节点最多只有两个孩子。如果二叉树的节点满足任意节点的键比其左孩子的值要大，比右孩子的值要小，称这样的二叉树为二叉搜索树。

2. 二叉搜索树代码事例

public class demo_BST {
    private int key;
    private Object value;
    private BSTNode left;
    private BSTNode right;
    // 根节点
    private BSTNode root;
    private class BSTNode{
        int key;
        Object value;
        BSTNode left;
        BSTNode right;
        public BSTNode(int key, Object value) {
            this.key = key;
            this.value = value;
        }

        public BSTNode(int key, Object value, BSTNode left, BSTNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
    // 构造二叉搜索树
    public void create_BSTree(){
        BSTNode n1 = new BSTNode(1, "AA");
        BSTNode n3 = new BSTNode(3, "BB");
        BSTNode n2 = new BSTNode(2, "CC", n1, n3);

        BSTNode n5 = new BSTNode(5, "DD");
        BSTNode n7 = new BSTNode(7, "EE");
        BSTNode n6 = new BSTNode(6, "FF", n5, n7);

        root = new BSTNode(4, "GG", n2, n6);
    }
    // 通过键返回树节点的一个值
    public Object doGet(int key){
        BSTNode p = root;
        while (p != null) {
            if (p.key < key) {
                p = p.right;
            } else if (p.key > key){
                p = p.left;
            } else {
                return p.value;
            }
        }
        return p;
    }
    // 返回搜索树最小的节点
    public Object doMin(){
        BSTNode p = root;
        while (p.left != null) {
            p = p.left;
        }
        if (p == null) {
            return null;
        }
        return p.value;
    }
    // 返回搜索树最大的节点
    public Object doMax(){
        BSTNode p = root;
        while (p.right != null) {
            p = p.right;
        }
        if (p == null) {
            return null;
        }
        return p.value;
    }
    private BSTNode doMax(BSTNode bst){
        BSTNode p = bst;
        while (p.right != null) {
            p = p.right;
        }
        return p;
    }
    private BSTNode doMin(BSTNode bst){
        BSTNode p = bst;
        while (p.left != null) {
            p = p.left;
        }
        return p;
    }
    //寻找该节点的前驱
    public Object prev_bstnode(int key){
        //如果该节点有左子树，则左子树的最大值就是该节点的前驱
        //如果没有左子树，则离它最近而且自左而来的节点就是该节点的前驱
        BSTNode p = root;
        BSTNode ancestor_left = null;
        while (p != null) {
            if (p.key < key) {
                ancestor_left = p;
                p = p.right;
            } else if (p.key > key){
                p = p.left;
            } else {
                break;
            }
        }
        if (p == null) {
            return p;
        }
        // 存在左子树,找到左子树的最大值
        if (p.left != null){
            return doMax(p.left).value;
        }
        // 不存在的话
        return ancestor_left == null ? null : ancestor_left.value;
    }
    //寻找该节点的后继
    public Object next_bstnode(int key){
        //如果该节点有右子树，则右子树的最小值就是该节点的后继
        //如果没有右子树，则离它最近而且自右而来的节点就是该节点的前驱
        BSTNode p = root;
        BSTNode ancestor_right = null;
        while (p != null) {
            if (p.key < key) {
                p = p.right;
            } else if (p.key > key){
                ancestor_right = p;
                p = p.left;
            } else {
                break;
            }
        }
        if (p == null) {
            return p;
        }
        // 存在右子树,找到右子树的最小值
        if (p.right != null){
            return doMin(p.right).value;
        }
        // 不存在的话
        return ancestor_right == null ? null : ancestor_right.value;
    }
}