LeetCode 432. 全 O(1) 的数据结构题解

432. 全 O(1) 的数据结构题解

题目来源：432. 全 O(1) 的数据结构

2022.03.16 每日一题

LeetCode 题解持续更新中Github仓库地址 CSDN博客地址

今天又是手撕数据结构的题目，啊，最害怕这种题目了

先让我们来分析一下题目吧

首先他要求全是 $O(1)$，其次，还要完成字符串数量的改变，如果数量为 0 就将其移除 ，最后还要获取出现次数的最大的，以及最小的

$O(1)$的实现可以通过哈希表进行实现，而这个删改怎么做到 $O(1)$呢

在学习 Java 的时候，我们知道 List 的实现类有 ArrayList 、LinkedList 等,ArrayList是易于查找的，LinkedList是易于修改的，因此，可以选择列表来帮助我们进行修改，所以可以将 哈希表与双向链表进行结合，最终得到如题所示的效果

我们首先可以通过使用双向链表用来存储 字符串序列和字符串出现的次数，字符串序列存放数量相同的字符串；还有前后的节点，为了方便定位 我们使用 哈希表，key 用来存放 字符串，val 存放 节点 。

添加和删除呢，就通过操纵链表就好了

首先，如果一个字符串没有出现过，那么添加之后，应该将其放入 Node.cnt==1 的位置中去，如果，出现过就应该放入其对应的值加一的位置中去，如果不存在相应的节点，就创建新的节点，将对应的值放入，由于我们创建的是一个双向链表，因为，向其中不断的增删元素也不会很麻烦，只需要更新相应的节点就行了，具体代码以及注释如下

// 创建列表的节点
class Node {
    // 创建值，统计当前字符串出现的次数
    public int cnt;
    // 常见一个 Set 序列，用来存放 cnt 相同的值
    public Set<String> set = new HashSet<>();
    // 创建前后节点
    public Node left, right;

    // 节点的构造函数
    public Node(int _cnt) {
        cnt = _cnt;
    }
}

class AllOne {
    // 首先创立一个头节点和一个尾节点，作为链表的边界
    // 方便后续寻找极值
    Node hh, tt;
    // 创建一个 HashMap 用来存储字符串以及相应的列表
    Map<String, Node> map = new HashMap<>();
    public AllOne() {
        // 将头尾节点附上初值，让其首位相连
        hh = new Node(-1000); tt = new Node(-1000);
        hh.right = tt; tt.left = hh;
    }

    void clear(Node node) {
        if (node.set.size() == 0) {
            node.left.right = node.right;
            node.right.left = node.left;
        }
    }

    public void inc(String key) {
        // 首先判断 原来是否包含此字符串
        if (map.containsKey(key)) {
            // 包含，就在原有基础上的set集合中删除当前的字符串
            Node node = map.get(key);
            node.set.remove(key);
            int cnt = node.cnt;
            // 创建一个 next 节点，用于存储
            Node next = null;
            // 判断是否存在 当前个数 +1 的字符串集合
            if (node.right.cnt == cnt + 1) {
                // 存在的话，直接将值赋给 next 节点
                next = node.right;
            } else {
                // 如果不存在就新建一个，赋给创建的 next 节点
                next = new Node(cnt + 1);
                // 并且更新 node 节点的 左右两个节点
                next.right = node.right;
                next.left = node;
                node.right.left = next;
                node.right = next;
            }
            // 将当前的 key 值，放入新的 node.right 中
            next.set.add(key);
            // 并且更新 map
            map.put(key, next);
            // 判断 node 节点中 set 的长度是否为 0
            // 为 0 就删除当前节点
            clear(node);
        } else {
            // 如果不包含就新建一个
            Node node = null;
            // 判断是否寻找出现此时是 1 的 Node 
            if (hh.right.cnt == 1) {
                node = hh.right;
            } else {
                // 为新放入的 字符串 创建一个 值为 1 的 Node
                node = new Node(1);
                // 更新 head 的右节点 (因为 1 是最小的了)
                node.right = hh.right;
                node.left = hh;
                hh.right.left = node;
                hh.right = node;
            }
            // 将 对应的值 加入 set 中
            node.set.add(key);
            // 并且更新 map
            map.put(key, node);
        }
    }

    // 移除元素的做法 与添加相反，但是大体思路相同
    public void dec(String key) {
        Node node = map.get(key);
        node.set.remove(key);
        int cnt = node.cnt;
        if (cnt == 1) {
            map.remove(key);
        } else {
            Node prev = null;
            if (node.left.cnt == cnt - 1) {
                prev = node.left;
            } else {
                prev = new Node(cnt - 1);
                prev.right = node;
                prev.left = node.left;
                node.left.right = prev;
                node.left = prev;
            }
            prev.set.add(key);
            map.put(key, prev);
        }
        clear(node);
    }

    public String getMaxKey() {
        // 节点 tt 在 链表的末尾，因此返回其 left 节点就能得到最大的Node值
        Node node = tt.left;
        for (String str : node.set) return str;
        return "";
    }

    public String getMinKey() {
        // Min 方法同理 
        // hh 在节点 的开头，返回 hh.right 就能返回相应值
        Node node = hh.right;
        for (String str : node.set) return str;
        return "";
    }
}