数据结构之映射Map

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

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

 1 package com.map;
 2 
 3 /**
 4  * @ProjectName: dataConstruct
 5  * @Package: com.map
 6  * @ClassName: Map
 7  * @Author: biehl
 8  * @Description: ${description}
 9  * @Date: 2020/3/14 17:37
10  * @Version: 1.0
11  */
12 public interface Map<K, V> {
13 
14     /**
15      * 映射Map的添加操作，键值对的形式新增元素
16      *
17      * @param key
18      * @param value
19      */
20     public void add(K key, V value);
21 
22     /**
23      * 映射Map中根据key的值删除key-value键值对，将key对应的value返回
24      *
25      * @param key
26      * @return
27      */
28     public V remove(K key);
29 
30     /**
31      * 判断映射是否包含某个key
32      *
33      * @param key
34      * @return
35      */
36     public boolean contains(K key);
37 
38     /**
39      * 映射Map中根据key的值获取到键值对的值
40      *
41      * @param key
42      * @return
43      */
44     public V get(K key);
45 
46     /**
47      * 向映射Map中设置键值对，即将key对应的value值修改成新的value值。
48      *
49      * @param key
50      * @param value
51      */
52     public void set(K key, V value);
53 
54     /**
55      * 获取到映射的大小
56      *
57      * @return
58      */
59     public int getSize();
60 
61     /**
62      * 判断映射Map是否为空
63      *
64      * @return
65      */
66     public boolean isEmpty();
67 }

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

  1 package com.map;
  2 
  3 import com.linkedlist.LinkedList;
  4 
  5 /**
  6  * @ProjectName: dataConstruct
  7  * @Package: com.map
  8  * @ClassName: LinkedListMap
  9  * @Author: biehl
 10  * @Description: ${description}
 11  * @Date: 2020/3/14 17:45
 12  * @Version: 1.0
 13  */
 14 public class LinkedListMap<K, V> implements Map<K, V> {
 15 
 16     // 链表是由一个一个节点组成
 17     private class Node {
 18         // 设置公有的，可以让外部类进行修改和设置值
 19         public K key;// 成员变量key存储键值对的键
 20         public V value;// 成员变量value存储键值对的值
 21         public Node next;// 成员变量next指向下一个节点，指向Node的一个引用
 22 
 23         /**
 24          * 含参构造函数
 25          *
 26          * @param key
 27          * @param value
 28          * @param next
 29          */
 30         public Node(K key, V value, Node next) {
 31             this.key = key;
 32             this.value = value;
 33             this.next = next;
 34         }
 35 
 36         /**
 37          * 无参构造函数
 38          */
 39         public Node() {
 40             this(null, null, null);
 41         }
 42 
 43         /**
 44          * 如果用户只传了key，那么可以调用含参构造函数，将next指定为null
 45          *
 46          * @param key
 47          */
 48         public Node(K key) {
 49             this(key, null, null);
 50         }
 51 
 52         /**
 53          * 重写toString方法
 54          *
 55          * @return
 56          */
 57         @Override
 58         public String toString() {
 59             return key.toString() + " : " + value.toString();
 60         }
 61 
 62     }
 63 
 64 
 65     private Node dummyHead;// Node类型的变量dummyHead，虚拟头节点
 66     private int size;// 链表要存储一个一个元素，肯定有大小，记录链表有多少元素
 67 
 68     /**
 69      * 无参的构造函数
 70      */
 71     public LinkedListMap() {
 72         // 虚拟头节点的元素是null空，初始化的时候next的值也为null空。
 73         dummyHead = new Node(null, null, null);// 初始化一个链表，虚拟头节点dummyHead是一个节点。
 74         // 链表大小是0，此时对于一个空的链表来说，是存在一个节点的，虚拟头节点。
 75         size = 0;// 大小size为0
 76     }
 77 
 78 
 79     /**
 80      * 获取链表的大小，获取链表中的元素个数
 81      *
 82      * @return
 83      */
 84     @Override
 85     public int getSize() {
 86         return size;
 87     }