基于二分搜索树实现映射Map

利用二分搜索树实现映射和链表稍微有些不同，在K的定义上是必须具备可比较性的

定义接口

Map.java

// 支持泛型，支持两个键和值
public interface Map<K, V> {
    void add(K key, V value);

    V remove(K key); // 删除后将key所对应的value返回给用户

    boolean contains(K key); // 查询是否包含

    V get(K key); // 获取键的值

    void set(K key, V newValue); // 修改键值对

    int getSize(); // 获取大小

    boolean isEmpty(); // 是否为空

}

Map类

相对难以理解的是删除元素的逻辑，使用递归考虑待删除元素与每一次的根节点进行比较。考虑待删除元素的左子树为空，右子树为空，或者左右子树均不为空三种情况。
BSTMap.java

import java.util.ArrayList;

// 由于是二分搜索树，对于key来说必须时刻比较的
public class BSTMap<K extends Comparable<K>, V> implements Map<K, V> {

    private class Node {
        public K key;  // key与value成对放在node里
        public V value;
        public Node left, right;

        // 构造方法
        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
        }
    }

    // 包含一个根节点和size
    private Node root;
    private int size;

    // 初始化构造
    public BSTMap() {
        root = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void add(K key, V value) {
        root = add(root, key, value);
    }

    // 向以node为根的二分搜索树中添加键值对(key,value)，递归算法
    // 返回插入新的键值对节点后二分搜索树的根
    private Node add(Node node, K key, V value) {
        if (node == null) {
            size++;
            return new Node(key, value);
        }
        // 如果没有递归到底，只对当前node的key进行比较，小于0往左子树添加，大于0往右子树添加
        if (key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if (key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else // key.compareTo(node.key) == 0 这种情况下更新value
            node.value = value;

        return node;
    }

    // 返回以node为根节点的二分搜索树中，key所在的节点
    private Node getNode(Node node, K key) {
        // node为null时，没有找到节点
        if (node == null)
            return null;

        // 如果等于0说明找到了key所在节点，直接返回该node
        if (key.compareTo(node.key) == 0)
            return node;
        else if (key.compareTo(node.key) < 0)
            return getNode(node.left, key); // 小于0去左子树找
        else //  if (key.compareTo(node.key) > 0)
            return getNode(node.right, key);
    }

    @Override
    public boolean contains(K key) {
        return getNode(root, key) != null; // 如果有为true，无false
    }

    @Override
    public V get(K key) {
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    @Override
    public void set(K key, V newValue) {
        Node node = getNode(root, key);
        if (node == null)
            throw new IllegalArgumentException(key + "doesn't exist.");
        node.value = newValue;
    }

    // 删除操作
    // 返回以node为根的二分搜索树的最小值所在的节点
    private Node minimum(Node node) {
        if (node.left == null)
            return node;
        return minimum(node.left);
    }

    // 删除以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node) {
        // 如果节点左子树为空，则将当前节点是最小值删除，它的右子树变为左子树
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    // 删除键所对应的节点同时返回键所对应的值
    @Override
    public V remove(K key) {
        // 先在二分搜索树中找一下是否存在该删除的节点
        Node node = getNode(root, key);
        // 如果找到调用递归函数删除节点
        if (node != null) {
            root = remove(root, key);
            // 删除完成之后返回key所对应的value
            return node.value;
        }
        // 否则删除的key不在映射中
        return null;
    }

    // 删除掉以node为根的二分搜索树中键为key的节点，递归算法
    // 返回删除节点后新的二分搜索树的根
    private Node remove(Node node, K key) {
        if (node == null)
            return null;
        // 比较key与node.key的值到具体的子树中进行删除
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            return node;
        }
        else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            return node;
        } else {
            // key.compareTo(node.key) == 0
            // 待删除节点左子树为空的情况
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            // 待删除节点右子树为空的情况
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }

            // 待删除节点左右子树均不为空
            // 先找到比待删除节点大的最小节点，右子树的最小节点
            // 用这个节点顶替待删除节点的位置
            Node successor = minimum(node.right); // 声明新的Node保存右子树最小节点
            successor.right = removeMin(node.right); // 后继节点的右子树等于右子树中删除掉最小节点
            successor.left = node.left; // 左子树等于待删除节点的左子树
            // 此时node节点已经没用了，将这颗节点与二分搜索树脱离关系
            node.left = node.right = null;
            // 这里不需要维护size--，因为在removeMin中已经维护过一次size--
            return successor; // 最后直接返回新的根是后继节点
        }
    }
    
}