【手写系列】映射

具体有难度的地方已在文中注释
映射接口：

package com.example.demo.handwrite;

/**
 * @author Jay
 * @date 2020/7/14 10:02
 * @Description:
 */
public interface Map<K,V> {
    void add(K key,V value);
    V remove(K key);
    void set(K key,V newValue);
    V get(K key);
    boolean isEmpty();
    int getSize();
    boolean contains(K key);
}

链表实现映射：

package com.example.demo.handwrite;

import javax.xml.soap.Node;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author Jay
 * @date 2020/7/14 10:04
 * @Description:
 */
public class LinkedListMap<K,V> implements Map<K,V> {
    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){
            this(key,null,null);
        }
        public Node (){
            this(null,null,null);
         }

        @Override
        public String toString() {
            return key.toString() + " : " + value.toString();
        }
    }
    private Node dummyHead;
    private int size;
    public LinkedListMap(){
        dummyHead=new Node();
        size=0;
    }

    private Node getNode(K key){
        Node cur=dummyHead.next;
        while (cur != null) {
            if (cur.equals(key))
                return cur;
            cur=cur.next;
        }
        return null;
    }


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


    @Override
    public V remove(K key) {
        Node prv=dummyHead;
        while (prv.next!=null){
            if (prv.next.value.equals(key))
                break;
            prv=prv.next;
        }
        if (prv.next!=null){
            Node delNode=prv.next;
            prv.next=delNode.next;
            delNode.next=null;
            return delNode.value;
        }
        return null;
    }

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

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

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

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

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

二叉查找树实现映射：

package com.example.demo.handwrite;

/**
 * @author Jay
 * @date 2020/7/20 20:37
 * @Description:
 */
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 void add(K key, V value) {
        add(root,key,value);
    }
    private Node add(Node root,K key,V value){
        if (null==root){
            ++size;
            return new Node(key,value);
        }
        if (key.compareTo(root.key)<0)
            root.left=add(root.left, key, value);
        if (key.compareTo(root.key)>0)
            root.right=add(root.right, key, value);
        else
            root.value=value;

        return root;
    }
    public Node getNode(Node root,K key){
        if (root==null)
            return null;
        if (root.key.compareTo(key)==0)
            return root;
        if (root.key.compareTo(key)<0)
            return root.left=getNode(root.left,key);
        else
           return root.right=getNode(root.right,key);

    }


    @Override
    public V remove(K key) {
        return null;
    }

    public Node remove(Node root,K key){
        if (root==null)
            return null;
        if (key.compareTo(root.key)<0) {
            root.left = getNode(root.left, key);
            return root;
        }
        else if (key.compareTo(root.key)>0) {
            root.right = getNode(root.right, key);
            return root;
        }else {
            if (root.left==null){
                Node rightNode=root.right;
                root.right=null;
                --size;
                return rightNode;
            }
            if (root.right==null){
                Node leftNode=root.left;
                root.left=null;
                --size;
                return leftNode;
            }
            Node succussor=Minimum(root.right);
            succussor.right=removeMin(root.right);
            succussor.left=root.left;
            root.right=root.left=null;
            return succussor;
        }

    }

    private Node removeMin(Node node) {
        if (node.left==null){
            Node rightNode=root.right;
            root.right=null;
            --size;
            return rightNode;
        }
        node.left=removeMin(root.left);
        return root;
    }

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

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

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

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

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