哈希部分题目以及个人理解

哈希部分题目以及个人理解

问答题

1、关于unordered_map和unordered_set说法错误的是（）
A.它们中存储元素的类型不同，unordered_map存储键值对，而unordered_set中只存储key
B.它们的底层结构相同，都使用哈希桶
C.它们查找的时间复杂度平均都是O(1)
D.它们在进行元素插入时，都得要通过key的比较去找待插入元素的位置

2、关于map和unordered_map说法不正确的是（）
A.它们中都存储的键值对
B.map适合key有序的场景，unordered_map没有有序的要求
C.它们中元素查找的方式相同
D.map的底层结构是红黑树，unordered_map的底层结构是哈希桶

3、已知有一个关键字序列：（19，14,23,1,68,20,84,27,55,11,10,79）散列存储在一个哈希表中，若散列函数为H（key）=key%7，并采用链地址法来解决冲突，则在等概率情况下查找成功的平均查找长度为()
A.1.5
B.1.7
C.2.0
D.2.3

4、采用开放定址法处理散列表的冲突时，其平均查找长度？ （）
A.高于链接法处理冲突
B.高于二分查找
C.低于链接法处理冲突
D.低于二分查找

5、用哈希（散列）方法处理冲突（碰撞）时可能出现堆积（聚集）现象，下列选项中，会受堆积现象直接影响的是 ()
A.存储效率
B.数列函数
C.装填（装载）因子
D.平均查找长度

6、采用线性探测法处理散列时的冲突,当从哈希表删除一个记录时,不应将这个记录的所在位置置空,因为这会影响以后的查找()
A.对
B.错
C.不一定
D.以上说法都不对

7、已知某个哈希表的n个关键字具有相同的哈希值，如果使用二次探测再散列法将这n个关键字存入哈希表，至少要进行（）次探测。
A.n-1
B.n
C.n+1
D.n(n+1)
E.n(n+1)/2
F.1+n(n+1)/2

编程题

1、重复n次的元素

class Solution {
public:
    int repeatedNTimes(vector<int>& nums)
    {
        //采取unordered_map来获取数列，并且统计各个数的出现次数。
        size_t N = nums.size() / 2;
        unordered_map<int, int> m;
        for (auto e : nums)
        {
            ++m[e];
        }
        //把出现次数为N的抽取出来
        for (auto a : m)
        {
            if (a.second == N)
            {
                return a.first;
            }

        }
        return -1;
    }
};

2、两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
    {
        //用nuordered_set去重
        unordered_set<int> s1;
        for (auto e : nums1)
        {
            s1.insert(e);
        }

        unordered_set<int> s2;
        for (auto e : nums2)
        {
            s2.insert(e);
        }
        vector<int> v;
        //遍历s1，并且用find（）函数在s2中找s1的值。找到插入v中。
        for (auto e : s1)
        {
            if (s2.find(e) != s2.end())
            {
                v.push_back(e);

            }
        }
        return v;
    }
};

3、两个数组的交集II

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        //用短的数组来比较长数组，提高效率
        if (nums1.size() < nums2.size())
        {
            vector<int> intersect(vector<int>&nums2, vector<int>&nums1);
        }
        //把短数组放到m中，建立键值对
        unordered_map<int, int> m;
        for (int a : nums1)
        {
            ++m[a];
        }
        //与长数组一个个比较，相同的放到v中，并且把m中的相同数个数逐个减少，
        //这样就可以达到（如果出现次数不一致，则考虑取较小值）
        vector<int> v;
        for (auto a : nums2)
        {
            if (m.count(a))
            {
                v.push_back(a);
                --m[a];
            }
            if (m[a] == 0)
            {
                m.erase(a);
            }

        }
        return v;
    }
};