面试基础知识整理 —— 二叉搜索树

1. 定义

二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

• 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 任意节点的左、右子树也分别为二叉查找树；
• 没有键值相等的节点。

摘自维基百科 二叉搜索树

2. 实现

二叉搜索树节点

package tree;

/**
 * Created by song on 4/8/17.
 *
 * 二叉搜索树节点
 */
public class BinaryNode<T extends Comparable> {

    private T value;

    private BinaryNode<T> left;

    private BinaryNode<T> right;

    public BinaryNode() {
        /*do nothing*/
    }

    public BinaryNode(T value) {
        this(value, null, null);
    }

    public BinaryNode(T value, BinaryNode<T> left, BinaryNode<T> right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public BinaryNode<T> getLeft() {
        return left;
    }

    public void setLeft(BinaryNode<T> left) {
        this.left = left;
    }

    public BinaryNode<T> getRight() {
        return right;
    }

    public void setRight(BinaryNode<T> right) {
        this.right = right;
    }
}

二叉搜索树

package tree;

/**
 * Created by song on 4/8/17.
 * <p>
 * 二叉搜索树
 */
public class BinarySearchTree<T extends Comparable> {

    private BinaryNode<T> root;

    public BinarySearchTree() {
        this(null);
    }

    public BinarySearchTree(BinaryNode<T> root) {
        this.root = root;
    }

    public boolean isEmpty() {
        return this.root == null;
    }

    public void clean() {
        this.root = null;
    }

    public T find(T t) {
        return valueAt(find(t, root));
    }

    public T findMin() {
        return valueAt(findMin(root));
    }

    public T findMax() {
        return valueAt(findMax(root));
    }

    public void insert(T t) {
        root = insert(t, root);
    }

    public void remove(T t) {
        root = remove(t, root);
    }

    public void printTree() {

    }

    private T valueAt(BinaryNode<T> node) {
        return node == null ? null : node.getValue();
    }

    @SuppressWarnings("unchecked")
    private BinaryNode<T> find(T x, BinaryNode<T> node) {
        if (node == null) {
            return null;
        }

        if (x.compareTo(node.getValue()) < 0) {
            return find(x, node.getLeft());
        } else if (x.compareTo(node.getValue()) > 0) {
            return find(x, node.getRight());
        } else {
            return node;
        }
    }

    private BinaryNode<T> findMin(BinaryNode<T> node) {
        if (node == null) {
            return null;
        }

        if (node.getLeft() == null) {
            return node;
        }

        return findMin(node.getLeft());
    }

    private BinaryNode<T> findMax(BinaryNode<T> node) {
        if (node == null) {
            return null;
        }

        if (node.getRight() == null) {
            return node;
        }

        return findMax(node.getRight());
    }

    @SuppressWarnings("unchecked")
    private BinaryNode<T> insert(T t, BinaryNode<T> node) {
        if (node == null) {
            node = new BinaryNode<>(t, null, null);
        }

        if (t.compareTo(node.getValue()) < 0) {
            node = insert(t, node.getLeft());
        } else if (t.compareTo(node.getValue()) > 0) {
            node = insert(t, node.getRight());
        } else {
            throw new RuntimeException("duplicate node");
        }

        return node;
    }

    @SuppressWarnings("unchecked")
    private BinaryNode<T> remove(T t, BinaryNode<T> node) {
        if (node == null) {
            return null;
        }

        if (t.compareTo(node.getValue()) < 0) {
            node.setLeft(remove(t, node.getLeft()));
        } else if (t.compareTo(node.getValue()) > 0) {
            node.setRight(remove(t, node.getRight()));
        } else if (node.getLeft() != null && node.getRight() != null) {
            node.setValue(findMin(node.getRight()).getValue());
            node.setRight(remove(node.getValue(), node.getRight()));
        } else {
            node = (node.getLeft() != null) ? node.getLeft() : node.getRight();
        }

        return node;
    }
}