更加复杂的数据结构

一、引言

        目前为止，我们接触了大量的数据结构，包括利用指针实现的三剑客和 C++ 自带的 STL 等。 对于一些题目，我们不仅需要利用多个数据结果解决问题，还需要把这些数据结构进行嵌套和联 动，进行更为复杂、更为快速的操作。

二、经典问题

1. 并查集

        并查集（union-find, 或 disjoint set）可以动态地连通两个点，并且可以非常快速地判断两个 点是否连通。假设存在 n 个节点，我们先将所有节点的父亲标为自己；每次要连接节点 i 和 j 时， 我们可以将 i 的父亲标为 j；每次要查询两个节点是否相连时，我们可以查找 i 和 j 的祖先是否最 终为同一个人。        

684. 冗余连接

684. Redundant Connection

        树可以看成是一个连通且 无环 的 无向 图。

        给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。

        请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n 个节点的树。如果有多个答案，则返回数组 edges 中最后出现的边。

        因为需要判断是否两个节点被重复连通，所以我们可以使用并查集来解决此类问题。具体实 现算法如下所示。

class UF{vector id;
public:UF(int n): id(n){// iota函数可以把数组初始化为0到n-1iota(id.begin(), id.end(), 0);}int find(int p){while(p != id[p]){p = id[p];}return p;}void connect(int p, int q){id[find(p)] = find(q);}bool isConnected(int p, int q){return find(p) == find(q);}
};class Solution {
public:vector findRedundantConnection(vector>& edges) {int n = edges.size();UF uf(n + 1);for(auto e: edges){int u = e[0], v= e[1];if(uf.isConnected(u, v)){return e;}uf.connect(u, v);}return vector{-1, -1};}
};

        为了加速查找，我们可以使用路径压缩和按秩合并来优化并查集。其具体写法如下所示。

class UF{vector id, size;
public:UF(int n): id(n), size(n, 1){// iota函数可以把数组初始化为0到n-1iota(id.begin(), id.end(), 0);}int find(int p){while(p != id[p]){id[p] = id[id[p]];  // 路径压缩，使得下次查找更快p = id[p];}return p;}void connect(int p, int q){int i = find(p), j = find(q);// 按秩合并：每次合并都把深度较小的集合合并在深度较大的集合下面if(i != j){if(size[i] < size[j]){id[i] = j;size[j] += size[i];}else{id[j] = i;size[i] += size[j];}}}bool isConnected(int p, int q){return find(p) == find(q);}
};

2. 复合数据结构

        这一类题通常采用 unordered_map 或 map 辅助记录，从而加速寻址；再配上 vector 或者 list 进行数据储存，从而加速连续选址或删除值。

146. LRU 缓存

146. LRU Cache

        请你设计并实现一个满足  LRU (最近最少使用) 缓存约束的数据结构。
实现 LRUCache 类：
        LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
        int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
        void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
        函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

        我们采用一个链表 list> 来储存信息的 key 和 value，链表的链接顺序即为最 近使用的新旧顺序，最新的信息在链表头节点。同时我们需要一个嵌套着链表的迭代器的 unordered_map>::iterator> 进行快速搜索，存迭代器的原因是方便调用链表的 splice 函数来直接更新查找成功（cash hit）时的信息，即把迭代器对应的节点移动为链表的头节点。

class LRUCache {unordered_map>::iterator> hash;list> cache;int size;
public:LRUCache(int capacity): size(capacity) {}int get(int key) {auto it = hash.find(key);if(it == hash.end()){return -1;}cache.splice(cache.begin(), cache, it->second);return it->second->second;}void put(int key, int value) {auto it = hash.find(key);if(it != hash.end()){it->second->second = value;return cache.splice(cache.begin(), cache, it->second);}cache.insert(cache.begin(), make_pair(key, value));hash[key] = cache.begin();if(cache.size() > size){hash.erase(cache.back().first);cache.pop_back();}}
};/*** Your LRUCache object will be instantiated and called as such:* LRUCache* obj = new LRUCache(capacity);* int param_1 = obj->get(key);* obj->put(key,value);*/

三、巩固练习

欢迎大家共同学习和纠正指教