数据结构之映射Map

1、映射Map，存储键值数据对的数据结构（key，value），可以根据键key快速寻找到值Value，可以使用链表或者二分搜索树实现的。

首先定义一个接口，可以使用链表或者二分搜索树进行实现。

package com.map;

/**
 * @ProjectName: dataConstruct
 * @Package: com.map
 * @ClassName: Map
 * @Author: biehl
 * @Description: ${description}
 * @Date: 2020/3/14 17:37
 * @Version: 1.0
 */
public interface Map<K, V> {

    /**
     * 映射Map的添加操作，键值对的形式新增元素
     *
     * @param key
     * @param value
     */
    public void add(K key, V value);

    /**
     * 映射Map中根据key的值删除key-value键值对，将key对应的value返回
     *
     * @param key
     * @return
     */
    public V remove(K key);

    /**
     * 判断映射是否包含某个key
     *
     * @param key
     * @return
     */
    public boolean contains(K key);

    /**
     * 映射Map中根据key的值获取到键值对的值
     *
     * @param key
     * @return
     */
    public V get(K key);

    /**
     * 向映射Map中设置键值对，即将key对应的value值修改成新的value值。
     *
     * @param key
     * @param value
     */
    public void set(K key, V value);

    /**
     * 获取到映射的大小
     *
     * @return
     */
    public int getSize();

    /**
     * 判断映射Map是否为空
     *
     * @return
     */
    public boolean isEmpty();
}

1.1、基于链表的映射实现的映射Map。

package com.map;

import com.linkedlist.LinkedList;

/**
 * @ProjectName: dataConstruct
 * @Package: com.map
 * @ClassName: LinkedListMap
 * @Author: biehl
 * @Description: ${description}
 * @Date: 2020/3/14 17:45
 * @Version: 1.0
 */
public class LinkedListMap<K, V> implements Map<K, V> {

    // 链表是由一个一个节点组成
    private class Node {
        // 设置公有的，可以让外部类进行修改和设置值
        public K key;// 成员变量key存储键值对的键
        public V value;// 成员变量value存储键值对的值
        public Node next;// 成员变量next指向下一个节点，指向Node的一个引用

        /**
         * 含参构造函数
         *
         * @param key
         * @param value
         * @param next
         */
        public Node(K key, V value, Node next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        /**
         * 无参构造函数
         */
        public Node() {
            this(null, null, null);
        }

        /**
         * 如果用户只传了key，那么可以调用含参构造函数，将next指定为null
         *
         * @param key
         */
        public Node(K key) {
            this(key, null, null);
        }

        /**
         * 重写toString方法
         *
         * @return
         */
        @Override
        public String toString() {
            return key.toString() + " : " + value.toString();
        }

    }


    private Node dummyHead;// Node类型的变量dummyHead，虚拟头节点
    private int size;// 链表要存储一个一个元素，肯定有大小，记录链表有多少元素

    /**
     * 无参的构造函数
     */
    public LinkedListMap() {
        // 虚拟头节点的元素是null空，初始化的时候next的值也为null空。
        dummyHead = new Node(null, null, null);// 初始化一个链表，虚拟头节点dummyHead是一个节点。
        // 链表大小是0，此时对于一个空的链表来说，是存在一个节点的，虚拟头节点。
        size = 0;// 大小size为0
    }


    /**
     * 获取链表的大小，获取链表中的元素个数
     *
     * @return
     */
    @Override
    public int getSize() {
        return size;
    }

    /**
     * 判断返回链表是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }


    /**
     * 根据映射Map的key获取到这个节点。
     *
     * @param key
     * @return
     */
    private Node getNode(K key) {
        // 获取到指向虚拟头节点的下一个节点，就是头部节点。
        Node current = dummyHead.next;
        // 循环遍历，如果不为空，就继续遍历
        while (current != null) {
            // 如果当前节点的键值对的键和你想要查询的键相等的话，就返回该节点
            if (current.key.equals(key)) {
                // 返回给当前要查询的节点
                return current;
            }
            // 如果不相等的话，就向下一个节点移动即可。
            current = current.next;
        }
        // 如果链表遍历完了，没有找到，就直接返回空即可。
        return null;
    }

    @Override
    public void add(K key, V value) {
        // 不允许有相同的key，即key不可以重复的。

        // 首先判断是否已经存在该key
        Node node = this.getNode(key);
        // 如果新增的key的值和保存的键值对的key值相等，那么这个新的key不能新增
        // 如果没有查到这个node，说明就可以新增了
        if (node == null) {
            // 这里是在链表的头部添加元素。
            // 在虚拟头节点的下一个节点，就是头部节点添加这个键值对
            dummyHead.next = new Node(key, value, dummyHead.next);
            // 维护size大小
            size++;
        } else {
            // 如果已经保存了该键值对。那么将新增的键值对的key对应的value值替换之前的value值
            node.value = value;
        }

    }

    @Override
    public V remove(K key) {
        // 定义一个起始节点，该节点从虚拟头节点开始
        Node prev = dummyHead;
        // 循环遍历，当前节点的下一个节点不为空就一直遍历
        while (prev.next != null) {
            // 如果当前节点的key的值等于想要删除的节点的key的值
            // 那么，此时prev的下一个节点保存的key，就是将要删除的节点。
            if (prev.next.key.equals(key)) {
                // 中断此循环
                break;
            }
            // 如果不是想要删除的节点，继续向下遍历
            prev = prev.next;
        }

        // 此时，如果prev的下一个节点不为空，那么该节点就是将要被删除的节点
        if (prev.next != null) {
            // 获取到这个将要被删除的节点
            Node delNode = prev.next;
            // 把将要被删除的这个节点的下一个节点赋值给prev这个节点的下一个节点，
            // 就是直接让prev指向将要被删除的节点的下一个节点。
            prev.next = delNode.next;
            // 此时将被删除的节点置空
            delNode.next = null;
            // 维护size的大小
            size--;
            // 返回被删除的节点元素
            return delNode.value;
        }
        // 如果没有找到待删除的节点，返回空
        return null;
    }

    @Override
    public boolean contains(K key) {
        // 根据key判断映射key里面是否包含key
        Node node = this.getNode(key);
        // 如果获取到node不为空，说明有这个元素，返回true。
        if (node != null) {
            return true;
        }
        return false;
    }

    @Override
    public V get(K key) {
        // 根据key获取到键值对的value值
//        Node node = this.getNode(key);
//        // 如果查询的节点返回不为空，说明存在该节点
//        if (node != null) {
//            // 返回该节点的value值
//            return node.value;
//        }
//        return null;

        // 根据key获取到键值对的value值
        Node node = this.getNode(key);
        return node == null ? null : node.value;
    }

    @Override
    public void set(K key, V value) {
        // 首先判断是否已经存在该key
        Node node = this.getNode(key);
        // 如果node节点等于空
        if (node == null) {
            throw new IllegalArgumentException(key + " doesn't exist!");
        } else {
            // 如果映射Map中存在了该键值对，那么进行更新操作即可
            node.value = value;
        }
    }

    public static void main(String[] args) {
        LinkedListMap<Integer, Integer> linkedListMap = new LinkedListMap<Integer, Integer>();
        // 基于链表实现的映射的新增
        for (int i = 0; i < 100; i++) {
            linkedListMap.add(i, i * i);
        }

//        for (int i = 0; i < linkedListMap.getSize(); i++) {
//            System.out.println(linkedListMap.get(i));
//        }


        // 基于链表实现的映射的修改
        linkedListMap.set(0, 111);
//        for (int i = 0; i < linkedListMap.getSize(); i++) {
//            System.out.println(linkedListMap.get(i));
//        }

        // 基于链表实现的映射的删除
        Integer remove = linkedListMap.remove(0);
//        for (int i = 0; i < linkedListMap.getSize(); i++) {
//            System.out.println(linkedListMap.get(i));
//        }

        // 基于链表实现的映射的获取大小
        System.out.println(linkedListMap.getSize());
    }

}

1.2、基于二分搜索树实现的映射Map。

package com.map;

import com.tree.BinarySearchTree;

/**
 * @ProjectName: dataConstruct
 * @Package: com.map
 * @ClassName: BinarySearchTreeMap
 * @Author: biehl
 * @Description: ${description}
 * @Date: 2020/3/14 19:57
 * @Version: 1.0
 */
public class BinarySearchTreeMap<K extends Comparable<K>, V> implements Map<K, V> {

    // 二分搜索树的节点类，私有内部类。
    private class Node {
        private K key;// 存储元素key;
        private V value;// 存储元素value;
        private Node left;// 指向左子树，指向左孩子。
        private Node right;// 指向右子树，指向右孩子。

        /**
         * 含参构造函数
         *
         * @param key
         */
        public Node(K key, V value) {
            this.key = key;// 键值对的key。
            this.value = value;// 键值对的value
            left = null;// 左孩子初始化为空。
            right = null;// 右孩子初始化为空。
        }
    }


    private Node root;// 根节点
    private int size;// 映射Map存储了多少个元素

    /**
     * 无参构造函数，和默认构造函数做的事情一样的。
     */
    public BinarySearchTreeMap() {
        // 初始化的时候，映射Map一个元素都没有存储
        root = null;
        size = 0;// 大小初始化为0
    }


    /**
     * 返回以node为根节点的二分搜索树中，key所在的节点。
     *
     * @param node
     * @param key
     * @return
     */
    private Node getNode(Node node, K key) {

        // 如果未找到指定的键值对的键值，那么直接返回空即可。
        if (node == null) {
            return null;
        }

        // 如果查询的key值和该节点的key值相等，直接返回该节点即可
        if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(key) < 0) {
            // 如果查询的key值小于该节点的key值，那么向该节点的左子树查询
            return getNode(node.left, key);
        } else if (key.compareTo(key) > 0) {
            // 如果查询的key值大于该节点的key值，那么向该节点的右子树查询
            return getNode(node.right, key);
        }
        return null;
    }


    /**
     * 返回以node为根的二分搜索树的最小值所在的节点
     *
     * @param node
     * @return
     */
    public Node minimum(Node node) {
        // 递归算法，第一部分，终止条件，如果node.left是空了，直接返回node节点
        if (node.left == null) {
            return node;
        }
        // 递归算法，第二部分，向node的左子树遍历
        return minimum(node.left);
    }

    /**
     * 删除掉以node为根的二分搜索树中的最小节点
     * 返回删除节点后新的二分搜索树的根
     *
     * @param node
     * @return
     */
    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;
    }


    /**
     * 向映射Map中添加新的键值对。
     *
     * @param key
     * @param value
     */
    @Override
    public void add(K key, V value) {
        // 此时，不需要对root为空进行特殊判断。
        // 向root中插入元素e。如果root为空的话，直接返回一个新的节点，将元素存储到该新的节点里面。
        root = add(root, key, value);
    }

    /**
     * 向以node为根的二分搜索树中插入元素键值对key-value，递归算法
     * 返回以插入心节点后二分搜索树饿根
     *
     * @param node
     * @param key
     * @param value
     * @return
     */
    private Node add(Node node, K key, V value) {
        if (node == null) {
            // 维护size的大小。
            size++;
            // 如果此时，直接创建一个Node的话，没有和二叉树挂接起来。
            // 如何让此节点挂接到二叉树上呢，直接将创建的节点return返回回去即可，返回给调用的上层。
            return new Node(key, value);
        }

        // 递归的第二部分。递归调用的逻辑。
        if (key.compareTo(node.key) < 0) {
            // 如果待插入元素e小于node的元素e，递归调用add方法，参数一是向左子树添加左孩子。
            // 向左子树添加元素e。
            // 向左子树添加元素e的时候，为了让整颗二叉树发生改变，在node的左子树中插入元素e，
            // 插入的结果，有可能是变化的，所以就要让node的左子树连接住这个变化。

            // 注意，如果此时，node.left是空的话，这次add操作相应的就会返回一个新的Node节点，
            // 对于这个新的节点，我们的node.left被赋值这个新的节点，相当于我们就改变了整棵二叉树。
            node.left = add(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            // 如果待插入元素e大于node的元素e，递归调用add方法，参数一是向右子树添加右孩子。
            // 向右子树添加元素e。
            node.right = add(node.right, key, value);
        } else if (key.compareTo(node.key) == 0) {
            // 如果想要插入的值是已经存在与映射里面了，那么将value值替换就行了。
            node.value = value;
        }

        return node;
    }

    /**
     * 从二分搜索树中删除元素为key的节点
     *
     * @param key
     * @return
     */
    @Override
    public V remove(K key) {
        Node node = getNode(root, key);
        if (node != null) {
            root = remove(root, key);
            return node.value;
        }
        // 不存在该节点
        return null;
    }

    /**
     * 删除掉以node为根的二分搜索树中健为key的节点，递归算法
     * 返回删除节点后新的二分搜索树的根
     *
     * @param node
     * @param key
     * @return
     */
    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }

        // 递归函数，开始近逻辑
        // 如果待删除元素e和当前节点的元素e进行比较，如果待删除元素e小于该节点的元素e
        if (key.compareTo(node.key) < 0) {
            // 此时，去该节点的左子树，去找到待删除元素节点
            // 递归调用，去node的左子树，去删除这个元素e。
            // 最后将删除的结果赋给该节点左子树。
            node.left = remove(node.left, key);
            return node;
        } else if (key.compareTo(node.key) > 0) {
            // 如果待删除元素e大于该节点的元素e
            // 去当前节点的右子树去寻找待删除元素节点
            // 将删除后的结果返回给当前节点的右孩子
            node.right = remove(node.right, key);
            return node;
        } else {
            // 当前节点元素e等于待删除节点元素e，即e == node.e，
            // 相等的时候，此时就是要删除这个节点的。

            // 如果当前节点node的左子树为空的时候，待删除节点左子树为空的情况
            if (node.left == null) {
                // 保存该节点的右子树
                Node rightNode = node.right;
                // 将node和这棵树断开关系
                node.right = null;
                // 维护size的大小
                size--;
                // 返回原来那个node的右孩子。也就是右子树的根节点，此时就将node删除掉了
                return rightNode;
            }

            // 如果当前节点的右子树为空，待删除节点右子树为空的情况。
            if (node.right == null) {
                // 保存该节点的左子树
                Node leftNode = node.left;
                // 将node节点和这棵树断开关系
                node.left = null;
                // 维护size的大小
                size--;
                //返回原来那个节点node的左孩子，也就是左子树的根节点，此时就将node删除掉了。
                return leftNode;
            }

            // 待删除节点左右子树均为不为空的情况。
            // 核心思路，找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
            // 用这个节点顶替待删除节点的位置。

            // 找到当前节点node的右子树中的最小节点，找到比待删除节点大的最小节点。
            // 此时的successor就是node的后继。
            Node successor = minimum(node.right);
            // 此时将当前节点node的右子树中的最小节点删除掉，并将二分搜索树的根节点返回。
            // 将新的二分搜索树的根节点赋值给后继节点的右子树。
            successor.right = removeMin(node.left);

            // 因为removeMin操作，删除了一个节点，但是此时当前节点的右子树的最小值还未被删除
            // 被successor后继者指向了。所以这里做一些size加加操作，
            size++;

            // 将当前节点的左子树赋值给后继节点的左子树上。
            successor.left = node.left;
            // 将node节点没有用了，将node节点的左孩子和右孩子置空。让node节点和二分搜索树脱离关系
            node.left = node.right = null;

            // 由于此时，将当前节点node删除掉了，所以这里做一些size减减操作。
            size--;

            // 返回后继节点
            return successor;
        }

    }

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

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

    @Override
    public void set(K key, V value) {
        Node node = getNode(root, key);
        // 如果映射中没有该节点
        if (node == null) {
            throw new IllegalArgumentException(key + " doesn't exist!");
        } else {
            node.value = value;
        }
    }

    /**
     * 获取到映射Map的大小
     *
     * @return
     */
    @Override
    public int getSize() {
        return size;
    }

    /**
     * 判断映射Map是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * @return
     */
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        // 使用一种形式展示整个二分搜索树，可以先展现根节点，再展现左子树，再展现右子树。
        // 上述这种过程就是一个前序遍历的过程。
        // 参数一，当前遍历的二分搜索树的根节点，初始调用的时候就是root。
        // 参数二，当前遍历的这棵二分搜索树的它的深度是多少，根节点的深度是0。
        // 参数三，将字符串传入进去，为了方便生成字符串。
        generateBSTString(root, 0, stringBuilder);

        return stringBuilder.toString();
    }

    /**
     * 生成以node为根节点，深度为depth的描述二叉树的字符串。
     *
     * @param node          节点
     * @param depth         深度
     * @param stringBuilder 字符串
     */
    private void generateBSTString(Node node, int depth, StringBuilder stringBuilder) {
        // 递归的第一部分
        if (node == null) {
            // 显示的，将在字符串中追加一个空字符串null。
            // 为了表现出当前的空节点对应的二分搜索树的层次，封装了一个方法。
            stringBuilder.append(generateDepthString(depth) + "null
");
            return;
        }


        // 递归的第二部分
        // 当当前节点不为空的时候，就可以直接访问当前的node节点了。
        // 将当前节点信息放入到字符串了
        stringBuilder.append(generateDepthString(depth) + node.key + "
");

        // 递归进行调用
        generateBSTString(node.left, depth + 1, stringBuilder);
        generateBSTString(node.right, depth + 1, stringBuilder);
    }

    /**
     * 为了表现出二分搜索树的深度
     *
     * @param depth
     * @return
     */
    private String generateDepthString(int depth) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            stringBuilder.append("--");
        }
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        BinarySearchTreeMap<Integer, Integer> binarySearchTreeMap = new BinarySearchTreeMap<Integer, Integer>();
        // 基于链表实现的映射的新增
        for (int i = 0; i < 100; i++) {
            binarySearchTreeMap.add(i, i * i);
        }
        System.out.println(binarySearchTreeMap.toString());


        // 基于链表实现的映射的修改
        binarySearchTreeMap.set(0, 111);
//        for (int i = 0; i < linkedListMap.getSize(); i++) {
//            System.out.println(linkedListMap.get(i));
//        }

        // 基于链表实现的映射的删除
        Integer remove = binarySearchTreeMap.remove(0);
//        for (int i = 0; i < linkedListMap.getSize(); i++) {
//            System.out.println(linkedListMap.get(i));
//        }

        // 基于链表实现的映射的获取大小
        System.out.println(binarySearchTreeMap.getSize());
    }
}

2、数据结构之映射Map，可以使用链表或者二分搜索树进行实现。它们的时间复杂度，分别如下所示：