请你设计一个用于存储字符串计数的数据结构，并能够返回计数最小和最大的字符串。

    实现 AllOne 类：

    AllOne() 初始化数据结构的对象。
    inc(String key) 字符串 key 的计数增加 1 。如果数据结构中尚不存在 key ，那么插入计数为 1 的 key 。
    dec(String key) 字符串 key 的计数减少 1 。如果 key 的计数在减少后为 0 ，那么需要将这个 key 从数据结构中删除。测试用例保证：在减少计数前，key 存在于数据结构中。
    getMaxKey() 返回任意一个计数最大的字符串。如果没有元素存在，返回一个空字符串 “” 。
    getMinKey() 返回任意一个计数最小的字符串。如果没有元素存在，返回一个空字符串 “” 。

    示例：

    输入
    [“AllOne”, “inc”, “inc”, “getMaxKey”, “getMinKey”, “inc”, “getMaxKey”, “getMinKey”]
    [[], [“hello”], [“hello”], [], [], [“leet”], [], []]
    输出
    [null, null, null, “hello”, “hello”, null, “hello”, “leet”]

    解释
    AllOne allOne = new AllOne();
    allOne.inc(“hello”);
    allOne.inc(“hello”);
    allOne.getMaxKey(); // 返回 “hello”
    allOne.getMinKey(); // 返回 “hello”
    allOne.inc(“leet”);
    allOne.getMaxKey(); // 返回 “hello”
    allOne.getMinKey(); // 返回 “leet”

    提示：

    1 <= key.length <= 10
    key 由小写英文字母组成
    测试用例保证：在每次调用 dec 时，数据结构中总存在 key
    最多调用 inc、dec、getMaxKey 和 getMinKey 方法 5 * 104 次

    1. class AllOne {
    2.     /**
    3.     定义node节点，双向链表，里面有cnt属性值记录次数，还有set集合保存key值， 用map存key与node的映射，当我们删除增加的时候，先寻找node左右是否有目标值，有的话就把key值存到目标节点的set中，没有则创建
    4.     */
    5.     class Node {
    6.         int cnt;
    7.         Node left, right;
    8.         Set<String> set = new HashSet<>();
    9.         public Node(int cnt) {
    10.             this.cnt = cnt;
    11.         }
    12.     }
    13.     //如果key数量为0，就要删除掉这个节点
    14.     public void clear(Node node) {
    15.         if (node.set.size() == 0) {
    16.             node.left.right = node.right;
    17.             node.right.left = node.left;
    18.         }
    19.     }
    21.     Node hh = new Node(-1), tt = new Node(-1);
    22.     Map<String, Node> map = new HashMap<>();
    24.     public AllOne() {
    25.         hh.right = tt;
    26.         tt.left = hh;
    27.     }
    29.     public void inc(String key) {
    30.         //map中有该节点
    31.         if (map.containsKey(key)) {
    32.             Node node = map.get(key);
    33.             //先删除set中的key值
    34.             node.set.remove(key);
    35.             Node next = null;
    36.             //分情况，有目标节点和无目标节点
    37.             if (node.right.cnt == node.cnt + 1) {
    38.                 next = node.right;
    39.             } else {
    40.                 next = new Node(node.cnt + 1);
    41.                 //更改指针
    42.                 node.right.left = next;
    43.                 next.right = node.right;
    44.                 node.right = next;
    45.                 next.left = node;
    46.             }
    47.             next.set.add(key);
    48.             //更新map
    49.             map.put(key, next);
    50.             clear(node);
    51.         } else {    //没有该节点
    52.             Node node = null;
    53.             if (hh.right.cnt == 1) {
    54.                 node = hh.right;
    55.             } else {
    56.                 node = new Node(1);
    57.                 //更改指针
    58.                 node.left = hh;
    59.                 node.right = hh.right;
    60.                 hh.right.left = node;
    61.                 hh.right = node;
    62.             }
    63.             node.set.add(key);
    64.             map.put(key, node);
    65.             //不存在clear
    66.         }
    67.     }
    69.     public void dec(String key) {
    70.         //删除必定map中存在
    71.         Node node = map.get(key);
    72.         node.set.remove(key);
    73.         Node pre = null;
    74.         //说明只出现一次，那么删除后就没有key值，所以直接map删即可
    75.         if (node.cnt == 1) {
    76.             map.remove(key);
    77.         } else {
    78.             if (node.left.cnt == node.cnt - 1) {
    79.                 pre = node.left;
    80.             } else {
    81.                 pre = new Node(node.cnt - 1);
    82.                 node.left.right = pre;
    83.                 pre.left = node.left;
    84.                 node.left = pre;
    85.                 pre.right = node;
    86.             }
    87.             pre.set.add(key);
    88.             map.put(key, pre);
    89.         }  
    90.         clear(node);
    91.     }
    93.     public String getMaxKey() {
    94.         Node node = tt.left;
    95.         //返回任意一个
    96.         for (String s : node.set) return s;
    97.         return "";
    98.     }
    100.     public String getMinKey() {
    101.         Node node = hh.right;
    102.         for (String s : node.set) return s;
    103.         return "";
    104.     }
    105. }
    107. /**
    108.  * Your AllOne object will be instantiated and called as such:
    109.  * AllOne obj = new AllOne();
    110.  * obj.inc(key);
    111.  * obj.dec(key);
    112.  * String param_3 = obj.getMaxKey();
    113.  * String param_4 = obj.getMinKey();
    114.  */