数据结构（9）：基于二分搜索树和链表的映射实现

1.映射定义

存储键值对的数据结构，实现根据键，查找值的功能。

2.映射实现功能

（1）void add(K,V)

（2）V remove(K)

（3）boolean contains(K)

（4）V get(K)

（5）void set(K,V)

（6）int getSize()

（7）boolean isEmpty()

（8）映射接口实现

public interface Map<K,V> {
    void add(K key,V value);
    V remove(K key);
    boolean contains(K key);
    V get(K key);
    void set(K key,V value);
    int getSize();
    boolean isEmpty();
}

3.映射的实现代码

（1）基于二分搜索树的实现Map

public class BSTMap<K extends Comparable<K>,V> implements Map<K,V> {
    //1.基本结构
    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;
        }
    }

    //2.存储结构
    private Node root;
    private int size;

    //3.构造函数
    public BSTMap(){
        root=null;
        size=0;
    }

    //4.获得基本信息
    @Override
    public int getSize() {
        return size;
    }

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

    //5.向二分搜索树中添加新的元素(key, value)
    @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);
        }
        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
            node.value=value;
        }
        return node;
    }

    //*******************************************************

    //6.查询元素

    /**
     * 6.1是否包含该元素
     * @param key
     * @return
     */
    @Override
    public boolean contains(K key) {
        return getNode(root,key)!=null;
    }
    // 【辅助函数：】返回以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);
        }
    }

    /**
     * 6.2 键的对应值
     * @param key
     * @return
     */
    @Override
    public V get(K key) {
        Node node=getNode(root,key);
        return node==null?null:node.value;
    }
    //**********************************************
    //7.更改
    @Override
    public void set(K key, V value) {
        Node node=getNode(root,key);
        if(node==null){
            throw new IllegalArgumentException(key + " doesn't exist!");
        }
        node.value=value;
    }

    //**********************************************
    //8.从二分搜索树中删除键为key的节点
    @Override
    public V remove(K key) {

        Node node=getNode(root,key);
        if(node!=null){
            root=remove(root,key);
            return node.value;
        }
        return null;
    }
    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;
        }
    }
     返回以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;
    }

}

（2）基于链表的实现Map

/**
 * LinkedList实现Map
 */
public class LinkedListMap<K,V> implements Map<K,V> {
    //1.基本存储结构
    private class Node{
        public K key;
        public V value;
        public Node next;

        public Node(K key,V value,Node next){
            this.key=key;
            this.value=value;
            this.next=next;
        }
        public Node(K key,V value){
            this(key,value,null);
        }
        public Node(){
            this(null,null,null);
        }
        @Override
        public String toString(){
            return key.toString() + " : " + value.toString();
        }
    }

    //2.存储基本信息
    private Node dummyHead;
    private int size;

    //3.构造函数
    public LinkedListMap(){
        dummyHead=new Node();
        size=0;
    }

    //4.获得基本信息
    @Override
    public int getSize() {
        return size;
    }

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

    //****************************************
    private Node getNode(K key){
        Node cur=dummyHead.next;
        while (cur!=null){
            if(cur.key.equals(key)){
                return cur;
            }
            cur=cur.next;
        }
        return null;
    }
    //****************************************
    //5.查询
    /**
     * 5.1 判断是否包含该键
     * @param key
     * @return
     */
    @Override
    public boolean contains(K key) {

        return getNode(key)!=null;
    }

    /**
     * 5.2 返回键对应值
     * @param key
     * @return
     */
    @Override
    public V get(K key) {
        Node node=getNode(key);
        return node==null?null:node.value;
    }
    //****************************************
    //6.增加
    @Override
    public void add(K key, V value) {
        Node node=getNode(key);
        if(node==null){
            dummyHead.next=new Node(key,value,dummyHead.next);
            size++;
        }else {
            node.value=value;
        }

    }
    //****************************************
    //7.修改
    @Override
    public void set(K key, V value) {
        Node node=getNode(key);
        if(node==null){
            throw new IllegalArgumentException(key + " doesn't exist!");
        }
        node.value=value;
    }
    //****************************************
    //8.删除
    @Override
    public V remove(K key) {
        Node prev=dummyHead;
        while (prev.next!=null){
            if(prev.next.key.equals(key)){
                break;
            }
            prev=prev.next;
        }
        if(prev.next!=null){
            Node delNode=prev.next;
            prev.next=delNode.next;
            delNode.next=null;
            size--;
            return delNode.value;
        }
        return null;
    }

}