C++:unordered_map/unordered_set

"只有我,守着安静的沙漠。等待着花开。"

---

 (一)unorderd系列容器;

(1)来源;

准确来说unordered系列关联式容器,是在C++ 11出来的。因为在C++98中引入了以红黑树为底层的map/set,但是当树的高度足够高,节点足够多时,查询的效率是不理想的。

本文中只对unordered_map和unordered_set进行介绍

unordered_multimap和unordered_multiset 和 multimap/multiset 异曲同工

 

(2)文档说明;

 

unordered_set; 

 

unordered_map;

 

---

 (二)关联式容器模拟实现;

unorderd 系列 底层封装的 哈希结构;

(1)结构

	template
	class unordered_set
	{
	public:
		struct SetOFT
		{
			K& operator()(const K& key)
			{
				return key;
			}
		};

	private:
		OpenHash::HashBuckets _us;
	};	

   template
	class unordered_map
	{
	public:
		struct MapOFT
		{
			K& operator()(const pair& kv)
			{
				return kv.first;
			}
		};

	private:
		OpenHash::HashBuckets,MapOFT> _um;
	};

插入部分也要相应更改;

 

---

(2) 迭代器;

哈希并没有提供 双向 迭代器。因为其底层本身就是实现的是单链表。  

 

注意的坑; 

    template>
    struct _Hashiterator
    {
        typedef HashData Node;
        Node* _node;
        typedef _Hashiterator Self;
        typedef HashBuckets HT;
        HT* _hp;
        _Hashiterator(Node* node, HT* hp)
            :_node(node),
            _hp(hp)
        {}

        T& operator*()
        {
            return _node->_data;
        }

        T* operator->()
        {
            return &_node->_data;
        }

        Self& operator++()
        {
            if (_node->_next)
            {
                //这里说明 同一块区域的 节点还没走完
                _node = _node->_next;
            }
            else
            {
                //需要换节点
              //找到当前 index
                size_t index = HashFunc()(KeyOFT()(_node->_data)) % _hp->_table.size();
                ++index;
                //index 完就结束
                while (index < _hp->_table.size())
                {
                    if (_hp->_table[index])
                    {
                        //不为空 就说明 下面挂了节点
                        _node = _hp->_table[index];
                        return *this;
                    }
                    else
                    {
                        ++index;
                    }
                }
                //说明已经没有节点了
                _node = nullptr;
            }
            return *this;
        }

        bool operator !=(const Self& s)
        {
            return _node != s._node;
        }

        bool operator ==(const Self& s)
        {
            return _node == s._node;
        }
    };

 

 ①迭代器封装;

        iterator begin()
        {
            size_t i = 0;
            while (i < _table.size())
            {
                if (_table[i])
                {
                    //this 可以作为 迭代器的哈希表传过去！
                    return iterator(_table[i], this);
                }
                ++i;
            }
            return end();

        }

        iterator end()
        {
            return iterator(nullptr,this);
        }

 

 (3)插入+[];

①unordered_map

	template
	class unordered_map
	{
		struct MapOFT
		{
			K& operator()(const pair& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename OpenHash::HashBuckets, MapOFT>::iterator iterator;

		iterator begin()
		{
			return _um.begin();
		}
		iterator end()
		{
			return _um.end();
		}

		pair insert(const pair& kv)
		{
			return _um.insert(kv);
		}

		V& operator[](const K& key)
		{
			pair* ret = _um.insert(make_pair(key, V()));
			return ret->first.second;
		}

	private:
		OpenHash::HashBuckets, MapOFT> _um;
	};

②unordered_set;

	template
	class unordered_set
	{
		struct SetOFT
		{
			K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename OpenHash::HashBuckets::iterator iterator;

		iterator begin()
		{
			return _us.begin();
		}
		iterator end()
		{
			return _us.end();
		}

		pair insert(const K& key)
		{
			return _us.insert(key);
		}

	private:
		OpenHash::HashBuckets _us;
	};

③HashBuckets；

 pair  insert(const T& data)
        {
            HashFunc hf;
            KeyOFT kot;

            Node* ret = find(kot(data));
            if (ret)
            {
                return make_pair(iterator(ret,this), false);
            }
            //哈希桶同样也需要 扩容
            //当负载因子 为 1 到时候扩容
            if (_n == _table.size())
            {
                vector NTable;
               // NTable._table.resize(_table.size() * 2);
                NTable.resize(GetNextPrime(_table.size()));
                // 这里不是拷贝赋值 而是让旧表里的指针
                //链接进新表
                for (int i = 0; i < _table.size() ; i++)
                {
                    if (_table[i])
                    {
                        //旧表节点
                        Node* cur = _table[i];
                        while (cur)
                        {
                            //记录 cur 的下一个  因为 头插 会改变cur->next
                            Node* next = cur->_next;
                            //重新计算映射位置
                            size_t index = hf(kot(data)) % NTable.size();

                            //头插
                            cur->_next = NTable[index];
                            NTable[index] = cur;

                            cur = next;
                        }
                        _table[i] = nullptr;
                    }
                }
                _table.swap(NTable);
            }

            //插入 哪个位置
            size_t index = hf(kot(data)) % _table.size();
            //去构建 一个节点nenode 以备插入

            Node* newnode = new Node(data);

            //插入选择头插 因为效率高
            newnode->_next = _table[index];
            _table[index] = newnode;
            ++_n;
            return make_pair(iterator(newnode,this),true);
        }

unordered_set 

 unordered_map;

 

---

(4)成员函数;

       //构造
        HashBuckets() = default;//显示指定生成 默认构造

        HashBuckets(const HashBuckets& HB)
        {
            _n = HB._n;
            _table.resize(HB._table.size());

            for (size_t i = 0;i < _table.size();++i)
            {
                Node* cur = HB._table[i];
                while (cur)
                {
                    Node* copy = new Node(cur->_data);

                    //再头插
                    copy->_next = _table[i];
                    _table[i] = copy;

                    cur = cur->_next;
                }
            }
        }

        //赋值
        HashBuckets& operator=(HashBuckets hb)
        {
            _table.swap(hb._table);
            swap(_n, hb._hp);
            return *this;
        }

 

---

本篇就到此为止,谢谢你的阅读

祝你好运~