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

于 2019-02-11 21:09:00 发布
阅读量123 收藏
点赞数
分类专栏： 数据结构 [Java]
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33669968/article/details/88889406
版权

映射ADT - Map

  • 注意Map接口中有两个泛型K，V；
public interface Map<K, V> {

    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>，K要能比较；
public class BSTMap<K extends Comparable<K>, V> implements Map<K, V> {

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

        BSTMap<String, Integer> 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
乌鲁木齐001号程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值