映射 02 基于二分搜索树的映射

映射ADT - Map

• 注意Map接口中有两个泛型K，V；

public interface Map {

    void add(K key, V value);
    boolean contains(K key);
    V get(K key);
    void set(K key, V value);
    V remove(K key);
    int getSize();
    boolean isEmpty();
    
}

基于BST的映射实现 - 基础

• 基于BST的Map实现，其实就是一个BST，只不过每个节点是个键值对；
• 基于BST的Map实现中的key的泛型是有边界的，K extends Comparable，K要能比较；

public class BSTMap, V> implements Map {

    private class Node{
        public K key;
        public V value;
        public Node left, right;

        public Node(K key, V value){
            this.key = key;
            this.value = value;
            left = null;
            right = null;
        }
    }

    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;
    }

}

辅助方法 - 根据key获取node

• 这个方法是个递归方法：从以node为根节点的二分搜索树中，返回key所在的节点；
• 规模更小的同一个问题是：从node的左子树中返回key所在的节点，从node的右子树中返回key所在的节点；
• 不能再缩小的基本问题是：对node情况的讨论；
  • 如果node == null，返回null；
  • 如果key.equals(node.key)，返回node；

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

    if(key.equals(node.key))
        return node;
    else if(key.compareTo(node.key) < 0)
        return getNode(node.left, key);
    else // if(key.compareTo(node.key) > 0)
        return getNode(node.right, key);
}

boolean contains(K key) - 根据key判断Map中是否存在包含key的节点

• 其实就是判断以root为根的BST中是否存在包含key的节点；

@Override
public boolean contains(K key){
    return getNode(root, key) != null;
}

V get(K key) - 根据key获取value

• 其实就是在以root为根的BST中取出包含key的节点；
  • 如果BST中有这个节点，就返回该节点的value；
  • 如果BST中没有这个节点，就返回null；

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

void set(K key, V newValue) - 修改key对应的value

• 在以root为根的BST中取出包含key的node；
  • 如果不存在这样的node，抛异常；
  • 如果存在这样的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;
}

V remove(K key) - 根据key删除键值对，并返回value

• 递归问题：取出以node为根的BST中的最小的节点；
• 规模更小的同一个问题是：取出以node.left为根的BST中最小的节点；
• 不能再缩小的基本问题是：node.left == null，此时node就是以node为根的BST中最小的节点；

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

• 递归问题：删除以node的根的BST的最小节点，并返回新BST的根；
• 规模更小的同一个问题是：删除以node.left为根的BST的最小节点，并返回新BST的根；
  • 返回的新BST的根要链到node.left；
  • 并将以node为根的，新组装好的BST返回；
• 不能再缩小的基本问题是：node.left == null，此时node就是以node为根的BST中最小的节点，需要把node删除；
  • Node rightNode = node.right即为新BST的根；
  • 让node与其右子树断开联系，node.right = null:
  • 维护整个BST中元素的个数，size --；
  • 返回rightNode；

// 删除掉以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;
}

• 根据key删除键值对并返回value，对于基于BST实现的Map来说就是，在以root
  为根的BST中删除包含key的节点；
• 首先判断以root为根的BST中是否存在包含key的节点：
  • 如果不存在，直接返回null；
  • 如果存在：
    • 问题转化为递归问题：在以node为根的BST中，删除包含key的节点，并返回新BST的根；
    • 返回包含key的节点的value；

@Override
public V remove(K key){
    Node node = getNode(root, key);
    if(node != null){
        root = remove(root, key);
        return node.value;
    }
    return null;
}

• 递归问题：在以node为根的BST中，删除包含key的节点，并返回新BST的根；
• 规模更小的同一个问题是：在node的左子树中删除包含key的节点，在node的右子树中删除包含key的节点；
  • 如果key.compareTo(node.key) < 0：
    • 在node的左子树中删除包含key的节点，并将返回的新BST的根链接到node.left；
    • 返回node；
  • 如果key.compareTo(node.key) > 0：
    • 在node的右子树中删除包含key的节点，并将返回的新BST的根链接到node.right；；
    • 返回node；
• 不能再缩小的基本问题是：对node情况的讨论；
  • 如果node == null，返回null；
  • 如果key.compareTo(node.key) == 0，说明node就是要删除的节点；
    • 如果node没有左孩子，断掉node和右孩子的关系，并返回右孩子，size --；
    • 如果node没有右孩子，断掉node和左孩子的关系，并返回左孩子，size --；
    • 如果node既有左孩子又有右孩子，采用Hibbard与1962年提出的Hibbard Deletion算法解决该问题：
      • 找出node右子树中最小的节点作为node的后继successor；
      • 删除node右子树中最小的节点，返回新BST的根，并链到successor.right；
      • 把node的左子树链到successor.left；
      • 断开node和左右子树的关系；
      • 返回successor；

private Node remove(Node node, K key){
    if( node == null )
        return null;

    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);
        successor.right = removeMin(node.right);
        successor.left = node.left;

        node.left = node.right = null;

        return successor;
    }
}

测试代码 - 词频统计

public static void main(String[] args){

    System.out.println("Pride and Prejudice");

    ArrayList words = new ArrayList<>();
    if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
        System.out.println("Total words: " + words.size());

        BSTMap map = new BSTMap<>();
        for (String word : words) {
            if (map.contains(word))
                map.set(word, map.get(word) + 1);
            else
                map.add(word, 1);
        }

        System.out.println("Total different words: " + map.getSize());
        System.out.println("Frequency of PRIDE: " + map.get("pride"));
        System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
    }

    System.out.println();
}

输出：

Pride and Prejudice
Total words: 125901
Total different words: 6530
Frequency of PRIDE: 53
Frequency of PREJUDICE: 11