Leetcode基础刷题记录（C++）——关联式容器

1.哈希表

通过哈希函数，为key分配一块内存地址，然后将key-value放到这块内存地址上。

哈希冲突：两个不同的key通过同一个哈希函数得到相同的内存地址。
解决方案之一：链地址法。通过链表吧冲突的键值对串起来。

访问元素	搜索元素	添加元素	删除元素
X	O(1)	O(1)	O(1)

当出现哈希冲突时，添加和删除的时间复杂度为O(k)，k为冲突元素个数。
但是在C++中，unordered_set和unordered_map的底层实现都是哈希表，不同的是后者是键值对(正宗哈希表)，前者只有key值，应该叫哈希集合。
例题：

• 389 找不同
  

class Solution {
public:
    char findTheDifference(string s, string t) {
        unordered_map<char, int> mpS;
        for (const auto& ch : s) {
            mpS[ch]++;
        }
        unordered_map<char, int> mpT;
        for (const auto& ch : t) {
            mpT[ch]++;
        }

        for (char ch = 'a'; ch <= 'z'; ch++) {
            if (mpS[ch] != mpT[ch]) {
                return ch;
            }
        }

        return -1;
    }
};

---

2.哈希集合

特点，元素不会重复。四种操作的时间复杂度与哈希表一致。
unordered_set()
例题：

• 217 存在重复元素
• 705 设计哈希集合
  

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> m1;
        for(int x:nums)
        {
            if(m1.find(x)!=m1.end())
            {
                return true;
            }
            m1.insert(x);
        }
        return false;
    }
};

---

构造哈希函数采用的是质数取模法，利用了同余的概念：当元素是个有规律的等差数列时，并且和基数（数组大小）最大公约数不为1时，就会造成哈希映射时冲突变高（数组某些位置永远不会有值）。

class MyHashSet {
private:
    vector<list<int>> data;
    static const int base = 769;
    static int hash(int key) { //构造哈希函数
        return key % base;
    }
public:
    MyHashSet(): data(base) {} //构造函数
    
    void add(int key) {
        int h = hash(key);
        for (auto it = data[h].begin(); it != data[h].end(); it++) {
            if ((*it) == key) { 
                return; //并未解决可能存在的哈希冲突
            }
        }
        data[h].push_back(key);
    }
    
    void remove(int key) {
        int h = hash(key);
        for (auto it = data[h].begin(); it != data[h].end(); it++) {
            if ((*it) == key) {
                data[h].erase(it);
                return;
            }
        }
    }
    
    bool contains(int key) {
        int h = hash(key);
        for (auto it = data[h].begin(); it != data[h].end(); it++) {
            if ((*it) == key) {
                return true;
            }
        }
        return false;
    }
};

---

3.堆

堆是一棵完全二叉树，每个节点大于等于（大顶堆）或者小于等于（小顶堆）它的孩子节点。常用于解决Top-K问题。

访问元素	搜索元素	添加元素	删除元素
X	O(1)	O(logN)	O(logN)

堆化：把一组无序的数加到堆里去。
例题：

• 215 数组中的第K个最大元素
• 692 前K个高频单词

虽然有容器库，但是还是建议会写 建堆，堆排序，堆删除的操作。但是有那么一个问题，为什么堆是一棵二叉树，但是拿数组实现的呢，在容器里也是基于队列实现的。

class Solution {
public:
    void buildHeap(vector<int>&nums, int heapSize){
        for(int i=heapSize/2-1;i>=0;--i){ 
        //leetcode答案里没有减一，但是应该是要减一的，不过不影响
            maxHeap(nums,i,heapSize);
        }
    }
    void maxHeap(vector<int> &nums,int i,int heapSize){
        int L=2*i+1,R=2*i+2,lagrest=i;
        if(L<heapSize && nums[L]>nums[lagrest]){
            lagrest=L;
        }
        if(R<heapSize && nums[R]>nums[lagrest]){
            lagrest=R;
        }
        if(lagrest!=i){
            swap(nums[i],nums[lagrest]);//swap()方法是在std库里的
            maxHeap(nums,lagrest,heapSize);
            //发生了交换操作后，应该检查被交换的孩子节点是否遵守大顶堆规则
        }
    }

    int findKthLargest(vector<int>& nums, int k) {
        int length=nums.size();
        buildHeap(nums,length);
        for(int i=0;i<k-1;i++){
            swap(nums[0],nums[length-1]);
            --length;//没有删除数组后面的数据，只是减小了检索范围
            maxHeap(nums,0,length);
        }
        return nums[0];
    }
};

---

思路：
1.首先利用哈希表记录每个单词出现的次数，key为单词，value为出现次数
2.然后就是根据题目的要求进行排序，那么问题就来了，如何排序呢？
（1）哈希表（unordered_map）的迭代器不支持随机访问，没有内置的.sort()方法。但是可以利用algorithm里的sort()算法，只需要写一个自定义的排序方法就可以了，重载<运算符和使用二元谓词这两种方法都可以。
（2）继续使用堆解决问题，但是同样需要调整大顶堆的排序规则。下面使用了容器优先队列/大小顶堆（priority_queue），所以重写Functional传入就行。
（3）而我一开始是暴力遍历哈希表做的…

定义：priority_queue<Type, Container, Functional>
Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 就是比较的方式，当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶堆

struct cmp { //一开始使用class报错
			//因为不写public或者private的时候,class默认是私有的
    bool operator()(pair<string, int> a, pair<string, int> b) {
        if (a.second == b.second) {
            return a.first < b.first;
        }
        else {
            return a.second > b.second;
        }
    }
};
class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        unordered_map<string, int> mp;
        for (auto ev : words) mp[ev]++;
        priority_queue<pair<string, int>, vector<pair<string, int>>, cmp> q;
        for (auto w : mp) {
            q.push(w);
            if (q.size() > k) q.pop();
        }
        vector<string> ans;
        while (!q.empty()) {
            ans.push_back(q.top().first);
            q.pop();
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

4.其它

关联容器里还剩 set/multiset 以及 map/multimap。它们的接口与哈希集合、哈希表基本一致。
由于set和map的底层是红黑树，所以它们的有序的，且是为了查找而存在的，所以在后面的算法部分再提到。

除此之外，还有两种数据结构，树和图。它们与上述同理，数据结构一般题目都会直接给出，考察点往往是算法，所以也再后续内容中学习。