STL C++之无序容器哈希表unordered_set/unordered_multiset/unordered_map/unordered_multimap

最新推荐文章于 2022-09-18 09:16:21 发布
最新推荐文章于 2022-09-18 09:16:21 发布
阅读量573 收藏 2
点赞数
分类专栏： C/C++ 文章标签： c++ 散列表 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Star_ID/article/details/126694290
版权

STL C++哈希容器

模板类unordered_set

template < class Key,                        // unordered_set::key_type/value_type
           class Hash = hash<Key>,           // unordered_set::hasher
           class Pred = equal_to<Key>,       // unordered_set::key_equal
           class Alloc = allocator<Key>      // unordered_set::allocator_type
           > class unordered_set;

无序集是以无特定顺序存储唯一元素的容器，并且允许根据它们的值快速检索单个元素。

在 unordered_set 中，元素的值同时也是它的键，唯一地标识它。 键是不可变的，因此，unordered_set 中的元素不能在容器中修改一次，但是可以插入和删除它们。

在内部，unordered_set 中的元素不是按任何特定顺序排序的，而是根据它们的哈希值组织成桶，以允许直接通过它们的值快速访问各个元素（平均时间复杂度恒定）。

unordered_set 容器比 set 容器更快地通过它们的键访问单个元素，尽管它们通常对于通过其元素的子集进行范围迭代的效率较低。

容器中的迭代器至少是前向迭代器。

创建C++ unordered_set容器

构造函数如下

empty (1)	explicit unordered_set ( size_type n = /* see below */,
                         const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& alloc = allocator_type() );
			explicit unordered_set ( const allocator_type& alloc );
range (2)	template <class InputIterator>
         	unordered_set ( InputIterator first, InputIterator last,
                         size_type n = /* see below */,
                         const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& alloc = allocator_type() );
copy (3)	unordered_set ( const unordered_set& ust );
			unordered_set ( const unordered_set& ust, const allocator_type& alloc );
move (4)	unordered_set ( unordered_set&& ust );
			unordered_set ( unordered_set&& ust, const allocator_type& alloc );
initializer list (5)	
			unordered_set ( initializer_list<value_type> il,
                size_type n = /* see below */,
                const hasher& hf = hasher(),
                const key_equal& eql = key_equal(),
                const allocator_type& alloc = allocator_type() );
构造版本含义
empty container constructor构造一个空的 unordered_set 对象，不包含任何元素且大小为零
range constructor构造一个 unordered_set 对象，其中包含 [first,last) 范围内每个元素的副本
copy constructor (and copying with allocator)该对象被初始化为具有与 ust unordered_set 对象相同的内容和属性
move constructor (and moving with allocator)该对象获取右值 ust 的内容
initializer list用列表的内容初始化容器

示例

// constructing unordered_sets
#include <iostream>
#include <string>
#include <unordered_set>

template<class T>
T cmerge(T a, T b) { T t(a); t.insert(b.begin(), b.end()); return t; }

int main()
{
	std::unordered_set<std::string> first;                                // empty
	std::unordered_set<std::string> second({ "red","green","blue" });     // init list
	std::unordered_set<std::string> third({ "orange","pink","yellow" });  // init list
	std::unordered_set<std::string> fourth(second);                       // copy
	std::unordered_set<std::string> fifth(cmerge(third, fourth));         // move
	std::unordered_set<std::string> sixth(fifth.begin(), fifth.end());    // range

	std::cout << "sixth contains:";
	for (const std::string& x : sixth) std::cout << " " << x;
	std::cout << std::endl;

	return 0;
}

输出

sixth contains: orange pink blue yellow green red

插入元素

(1)	pair<iterator,bool> insert ( const value_type& val );
(2)	pair<iterator,bool> insert ( value_type&& val );
(3)	iterator insert ( const_iterator hint, const value_type& val );
(4)	iterator insert ( const_iterator hint, value_type&& val );
(5)	template <class InputIterator>
    void insert ( InputIterator first, InputIterator last );
(6)	void insert ( initializer_list<value_type> il );

在 unordered_set 中插入新元素。

仅当每个元素不等于容器中已有的任何其他元素时才插入每个元素（unordered_set 中的元素具有唯一值）

// unordered_set::insert
#include <iostream>
#include <string>
#include <array>
#include <unordered_set>

int main()
{
	std::unordered_set<std::string> myset = { "yellow","green","blue" };
	std::array<std::string, 2> myarray = { "black","white" };
	std::string mystring = "red";

	myset.insert(mystring);                          // copy insertion
	myset.insert(mystring + "dish");                 // move insertion
	myset.insert(myarray.begin(), myarray.end());    // range insertion
	myset.insert({ "purple","orange" });             // initializer list insertion

	std::cout << "myset contains:";
	for (const std::string& x : myset) std::cout << " " << x;
	std::cout << std::endl;

	return 0;
}

输出

myset contains: yellow black red green blue reddish white purple orange

删除元素

by position (1)	iterator erase ( const_iterator position );
by key (2)	size_type erase ( const key_type& k );
range (3)	iterator erase ( const_iterator first, const_iterator last );

// unordered_set::erase
#include <iostream>
#include <string>
#include <unordered_set>

int main()
{
	std::unordered_set<std::string> myset =
	{ "USA","Canada","France","UK","Japan","Germany","Italy" };

	myset.erase(myset.begin());                    // erasing by iterator
	myset.erase("France");                         // erasing by key
	myset.erase(myset.find("Japan"), myset.end()); // erasing by range

	std::cout << "myset contains:";
	for (const std::string& x : myset) std::cout << " " << x;
	std::cout << std::endl;

	return 0;
}

可能输出

myset contains:

查找元素

      iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const;

在容器中搜索以 k 为值的元素，如果找到则返回一个迭代器，否则返回一个迭代器到 unordered_set::end（容器末尾的元素）

// unordered_set::find
#include <iostream>
#include <string>
#include <unordered_set>

int main()
{
    std::unordered_set<std::string> myset = { "red","green","blue" };

    std::string input;
    std::cout << "color? ";
    getline(std::cin, input);

    std::unordered_set<std::string>::const_iterator got = myset.find(input);

    if (got == myset.end())
        std::cout << "not found in myset";
    else
        std::cout << *got << " is in myset";

    std::cout << std::endl;

    return 0;
}

输出

color? red
red is in myset

模板类unordered_multiset

std::unordered_multiset

template < class Key,                         // unordered_multiset::key_type/value_type
           class Hash = hash<Key>,            // unordered_multiset::hasher
           class Pred = equal_to<Key>,        // unordered_multiset::key_equal
           class Alloc = allocator<Key>       // unordered_multiset::allocator_type
           > class unordered_multiset;

无序多重集是不按特定顺序存储元素的容器，允许根据值快速检索单个元素，很像 unordered_set 容器，但允许不同元素具有等效值。

在 unordered_multiset 中，元素的值同时也是它的键，用于标识它。键是不可变的，因此，unordered_multiset 中的元素不能在容器中修改一次 - 但是可以插入和删除它们。

在内部，unordered_multiset 中的元素没有任何特定的排序，而是根据它们的哈希值组织到桶中，以允许直接通过它们的值快速访问单个元素（平均具有恒定的平均时间复杂度）。

具有等效值的元素被组合在同一个桶中，并且迭代器（参见 equal_range）可以遍历所有元素。

容器中的迭代器至少是前向迭代器。

请注意，此容器未在其自己的标头中定义，而是与 unordered_set 共享标头 <unordered_set>。

创建C++ unordered_multiset容器

empty (1)	explicit unordered_multiset ( size_type n = /* see below */,
                              const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& alloc = allocator_type() );
			explicit unordered_multiset ( const allocator_type& alloc );
range (2)	template <class InputIterator>
         	unordered_multiset ( InputIterator first, InputIterator last,
                              size_type n = /* see below */,
                              const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& alloc = allocator_type() );
copy (3)	unordered_multiset ( const unordered_multiset& ums );
			unordered_multiset ( const unordered_multiset& ums, const allocator_type& alloc );
move (4)	unordered_multiset ( unordered_multiset&& ums );
			unordered_multiset ( unordered_multiset&& ums, const allocator_type& alloc );
initializer list (5)	
unordered_multiset ( initializer_list<value_type> il,
                     size_type n = /* see below */,
                     const hasher& hf = hasher(),
                     const key_equal& eql = key_equal(),
                     const allocator_type& alloc = allocator_type() );

// constructing unordered_multisets
#include <iostream>
#include <string>
#include <unordered_set>

template<class T>
T cmerge(T a, T b) { T t(a); t.insert(b.begin(), b.end()); return t; }

int main()
{
	std::unordered_multiset<std::string> first;									// empty
	std::unordered_multiset<std::string> second({ "red","green","blue" });		// init list
	std::unordered_multiset<std::string> third({ "red","yellow","blue" });		// init list
	std::unordered_multiset<std::string> fourth(second);						// copy
	std::unordered_multiset<std::string> fifth(cmerge(third, fourth));			// move
	std::unordered_multiset<std::string> sixth(fifth.begin(), fifth.end());		// range

	std::cout << "sixth contains:";
	for (const std::string& x : sixth) std::cout << " " << x;
	std::cout << std::endl;

	return 0;
}

输出

sixth contains: red red green yellow blue blue

插入元素

(1)	iterator insert ( const value_type& val );
(2)	iterator insert ( value_type&& val );
(3)	iterator insert ( const_iterator hint, const value_type& val );
(4)	iterator insert ( const_iterator hint, value_type&& val );
(5)	template <class InputIterator>
    void insert ( InputIterator first, InputIterator last );
(6)	void insert ( initializer_list<value_type> il );

// unordered_multiset::insert
#include <iostream>
#include <string>
#include <array>
#include <unordered_set>

int main()
{
	std::unordered_multiset<std::string> myums = { "red","green","blue" };
	std::array<std::string, 2> myarray = { "red","yellow" };
	std::string mystring = "red";

	myums.insert(mystring);                        // copy insertion
	myums.insert(mystring + "dish");                 // move insertion
	myums.insert(myarray.begin(), myarray.end());  // range insertion
	myums.insert({ "purple","orange" });           // initializer list insertion

	std::cout << "myums contains:";
	for (const std::string& x : myums) std::cout << " " << x;
	std::cout << std::endl;

	return 0;
}

输出

myums contains: green red red red blue reddish yellow purple orange

删除元素

by position (1)	iterator erase ( const_iterator position );
by key (2)		size_type erase ( const key_type& k );
range (3)		iterator erase ( const_iterator first, const_iterator last );

从 unordered_multiset 容器中删除值为 k 的元素或元素范围 ([first,last))

// unordered_multiset::erase
#include <iostream>
#include <string>
#include <unordered_set>

int main ()
{
  std::unordered_multiset<std::string> myums =
  {"fish","duck","cow","cow","pig","hen","sheep"};

  myums.erase ( myums.begin() );                    // erasing by iterator
  myums.erase ( "sheep" );                          // erasing by key
  myums.erase ( myums.find("fish"), myums.end() );  // erasing by range

  std::cout << "myums contains:";
  for ( const std::string& x: myums ) std::cout << " " << x;
  std::cout << std::endl;

  return 0;
}

可能输出

myums contains: hen cow cow duck pig

查找元素

      iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const;

在容器中搜索以 k 为值的元素，如果找到则返回一个迭代器，否则返回一个迭代器到 unordered_set::end（容器末尾的元素）。

// unordered_multiset::find
#include <iostream>
#include <string>
#include <unordered_set>

int main()
{
    std::unordered_multiset<std::string> myums =
    { "cow","cow","pig","sheep","pig" };

    std::unordered_multiset<std::string>::iterator it = myums.find("pig");

    if (it != myums.end())
        std::cout << *it << " found" << std::endl;

    return 0;
}

输出

pig found

模板类unordered_map

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
           > class unordered_map;

无序映射是关联容器，它存储由键值和映射值组合形成的元素，并允许基于键快速检索各个元素。

在 unordered_map 中，键值一般用于唯一标识元素，而映射的值是与该键关联的内容的对象。键和映射值的类型可能不同。

在内部，unordered_map 中的元素并没有根据它们的键值或映射值按任何特定顺序排序，而是根据它们的哈希值组织到存储桶中，以允许通过它们的键值直接快速访问单个元素（使用常量平均时间复杂度）。

unordered_map 容器比 map 容器更快地通过其键访问单个元素，尽管它们通常对于通过其元素的子集进行范围迭代的效率较低。

无序映射实现了直接访问运算符 (operator[])，它允许使用其键值作为参数直接访问映射值。

容器中的迭代器至少是前向迭代器。

创建C++ unordered_map容器

构造函数如下

empty (1)	explicit unordered_map ( size_type n = /* see below */,
			                         const hasher& hf = hasher(),
			                         const key_equal& eql = key_equal(),
			                         const allocator_type& alloc = allocator_type() );
			explicit unordered_map ( const allocator_type& alloc );
range (2)	template <class InputIterator>
  			unordered_map ( InputIterator first, InputIterator last,
							size_type n = /* see below */,
							const hasher& hf = hasher(),
							const key_equal& eql = key_equal(),
		                  	const allocator_type& alloc = allocator_type() );
copy (3)	unordered_map ( const unordered_map& ump );
			unordered_map ( const unordered_map& ump, const allocator_type& alloc );
move (4)	unordered_map ( unordered_map&& ump );
			unordered_map ( unordered_map&& ump, const allocator_type& alloc );
initializer list (5)	
			unordered_map ( initializer_list<value_type> il,
				            size_type n = /* see below */,
				            const hasher& hf = hasher(),
				            const key_equal& eql = key_equal(),
				            const allocator_type& alloc = allocator_type() );
构造版本含义
empty container constructor构造一个空的 unordered_map 对象，不包含任何元素且大小为零
range constructor构造一个 unordered_map 对象，其中包含 [first,last) 范围内每个元素的副本
copy constructor (and copying with allocator)该对象被初始化为具有与 unordered_map 对象相同的内容和属性
move constructor (and moving with allocator)该对象获取右值 ump 的内容
initializer list用列表的内容初始化容器
// constructing unordered_maps
#include <iostream>
#include <string>
#include <unordered_map>

typedef std::unordered_map<std::string, std::string> stringmap;

stringmap merge(stringmap a, stringmap b) {
	stringmap temp(a); 
	temp.insert(b.begin(), b.end()); 
	return temp;
}

int main()
{
	stringmap first;												// empty
	stringmap second({ {"apple","red"},{"lemon","yellow"} });       // init list
	stringmap third({ {"orange","orange"},{"strawberry","red"} });  // init list
	stringmap fourth(second);										// copy
	stringmap fifth(merge(third, fourth));							// move
	stringmap sixth(fifth.begin(), fifth.end());					// range

	std::cout << "sixth contains:";
	for (auto& x : sixth) std::cout << " " << x.first << ":" << x.second;
	std::cout << std::endl;

	return 0;
}

输出

sixth contains: orange:orange strawberry:red apple:red lemon:yellow

插入元素

(1)	pair<iterator,bool> insert ( const value_type& val );
(2)	template <class P>
    pair<iterator,bool> insert ( P&& val );
(3)	iterator insert ( const_iterator hint, const value_type& val );
(4)	template <class P>
    iterator insert ( const_iterator hint, P&& val );
(5)	template <class InputIterator>
    void insert ( InputIterator first, InputIterator last );
(6)	void insert ( initializer_list<value_type> il );

在 unordered_map 中插入新元素。

只有当每个元素的键不等于容器中已经存在的任何其他元素的键时，才会插入每个元素（unordered_map 中的键是唯一的）

// unordered_map::insert
#include <iostream>
#include <string>
#include <unordered_map>

int main()
{
    std::unordered_map<std::string, double>
        myrecipe,
        mypantry = { {"milk",2.0},{"flour",1.5} };

    std::pair<std::string, double> myshopping("baking powder", 0.3);

    myrecipe.insert(myshopping);                                       // copy insertion
    myrecipe.insert(std::make_pair<std::string, double>("eggs", 6.0)); // move insertion
    myrecipe.insert(mypantry.begin(), mypantry.end());                 // range insertion
    myrecipe.insert({ {"sugar",0.8},{"salt",0.1} });                   // initializer list insertion

    std::cout << "myrecipe contains:" << std::endl;
    for (auto& x : myrecipe)
        std::cout << x.first << ": " << x.second << std::endl;

    std::cout << std::endl;
    return 0;
}

输出

myrecipe contains:
baking powder: 0.3
flour: 1.5
eggs: 6
milk: 2
sugar: 0.8
salt: 0.1

删除元素

by position (1)	iterator erase ( const_iterator position );
by key (2)	size_type erase ( const key_type& k );
range (3)	iterator erase ( const_iterator first, const_iterator last );

// unordered_map::erase
#include <iostream>
#include <string>
#include <unordered_map>

int main()
{
    std::unordered_map<std::string, std::string> mymap;

    // populating container:
    mymap["U.S."] = "Washington";
    mymap["U.K."] = "London";
    mymap["France"] = "Paris";
    mymap["Russia"] = "Moscow";
    mymap["China"] = "Beijing";
    mymap["Germany"] = "Berlin";
    mymap["Japan"] = "Tokyo";

    // erase examples:
    mymap.erase(mymap.begin());      // erasing by iterator
    mymap.erase("France");             // erasing by key
    mymap.erase(mymap.find("China"), mymap.end()); // erasing by range

    // show content:
    for (auto& x : mymap)
        std::cout << x.first << ": " << x.second << std::endl;

    return 0;
}

可能输出

U.S.: Washington
Russia: Moscow

查找元素

      iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const;

在容器中搜索以 k 为键的元素，如果找到则返回一个迭代器，否则返回一个迭代器到 unordered_map::end（容器末尾的元素）

// unordered_map::find
#include <iostream>
#include <string>
#include <unordered_map>

int main()
{
    std::unordered_map<std::string, double> mymap = {
       {"mom",5.4},
       {"dad",6.1},
       {"bro",5.9} };

    std::string input;
    std::cout << "who? ";
    getline(std::cin, input);

    std::unordered_map<std::string, double>::const_iterator got = mymap.find(input);

    if (got == mymap.end())
        std::cout << "not found";
    else
        std::cout << got->first << " is " << got->second;

    std::cout << std::endl;

    return 0;
}

输出

who? mom
mom is 5.4

模板类unordered_multimap

template < class Key,                                    // unordered_multimap::key_type
           class T,                                      // unordered_multimap::mapped_type
           class Hash = hash<Key>,                       // unordered_multimap::hasher
           class Pred = equal_to<Key>,                   // unordered_multimap::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_multimap::allocator_type
           > class unordered_multimap;

无序多映射是存储由键值和映射值组合形成的元素的关联容器，很像 unordered_map 容器，但允许不同的元素具有等效的键。

在 unordered_multimap 中，键值一般用于唯一标识元素，而映射的值是与该键关联的内容的对象。 键和映射值的类型可能不同。

在内部，unordered_multimap 中的元素并没有根据它们的键或映射值按任何特定顺序排序，而是根据它们的哈希值组织成桶，以允许直接通过它们的键值快速访问单个元素（使用常量 平均时间复杂度）。

具有等效键的元素被组合在同一个桶中，并且迭代器（参见 equal_range）可以遍历所有元素。

容器中的迭代器至少是前向迭代器。

创建C++ unordered_multimap容器

empty (1)	explicit unordered_multimap ( size_type n = /* see below */,
                              const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& alloc = allocator_type() );
			explicit unordered_multimap ( const allocator_type& alloc );
range (2)	template <class InputIterator>
         	unordered_multimap ( InputIterator first, InputIterator last,
                              size_type n = /* see below */,
                              const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& alloc = allocator_type() );
copy (3)	unordered_multimap ( const unordered_multimap& umm );
			unordered_multimap ( const unordered_multimap& umm, const allocator_type& alloc );
move (4)	unordered_multimap ( unordered_multimap&& umm );
			unordered_multimap ( unordered_multimap&& umm, const allocator_type& alloc );
initializer list (5)	
unordered_multimap ( initializer_list<value_type> il, size_type n = /* see below */,
                     const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                     const allocator_type& alloc = allocator_type() );

// constructing unordered_multimaps
#include <iostream>
#include <string>
#include <unordered_map>

typedef std::unordered_multimap<std::string, std::string> stringmap;

stringmap merge(stringmap a, stringmap b) {
	stringmap temp(a); temp.insert(b.begin(), b.end()); return temp;
}

int main()
{
	stringmap first;												// empty
	stringmap second({ {"apple","red"},{"lemon","yellow"} });       // init list
	stringmap third({ {"apple","green"},{"strawberry","red"} });    // init list
	stringmap fourth(second);										// copy
	stringmap fifth(merge(third, fourth));							// move
	stringmap sixth(fifth.begin(), fifth.end());					// range

	std::cout << "sixth contains:";
	for (auto& x : sixth) std::cout << " " << x.first << ":" << x.second;
	std::cout << std::endl;

	return 0;
}

输出

sixth contains: apple:green apple:red strawberry:red lemon:yellow

插入元素

(1)	iterator insert ( const value_type& val );
(2)	template <class P>
    iterator insert ( P&& val );
(3)	iterator insert ( const_iterator hint, const value_type& val );
(4)	template <class P>
    iterator insert ( const_iterator hint, P&& val );
(5)	template <class InputIterator>
    void insert ( InputIterator first, InputIterator last );
(6)	void insert ( initializer_list<value_type> il );

// unordered_multimap::insert
#include <iostream>
#include <string>
#include <unordered_map>

int main()
{
    std::unordered_multimap<std::string, int>
        first,
        second = { {"AAPL",200},{"GOOG",100} };

    std::pair<std::string, int> mypair("MSFT", 500);

    first.insert(mypair);                            // copy insertion
    first.insert(std::make_pair<std::string, int>("GOOG", 50)); // move insertion
    first.insert(second.begin(), second.end());  // range insertion
    first.insert({ {"ORCL",100},{"GOOG",100} });    // initializer list insertion

    std::cout << "first contains:" << std::endl;
    for (auto& x : first)
        std::cout << x.first << ": " << x.second << std::endl;

    std::cout << std::endl;
    return 0;
}

输出

first contains:
ORCL: 100
AAPL: 200
MSFT: 500
GOOG: 50
GOOG: 100
GOOG: 10

删除元素

by position (1)	iterator erase ( const_iterator position );
by key (2)	size_type erase ( const key_type& k );
range (3)	iterator erase ( const_iterator first, const_iterator last );

// unordered_multimap::erase
#include <iostream>
#include <unordered_map>

int main()
{
    std::unordered_multimap<std::string, std::string> myumm = {
           {"strawberry","red"},
           {"banana","yellow"},
           {"orange","orange"},
           {"lemon","yellow"},
           {"apple","red"},
           {"apple","green"},
           {"pear","green"},
    };


    // erase examples:
    myumm.erase(myumm.begin());     // erasing by iterator
    myumm.erase("apple");             // erasing by key (erases 2 elements)
    myumm.erase(myumm.find("orange"), myumm.end()); // erasing by range

    // show content:
    for (auto& x : myumm)
        std::cout << x.first << ": " << x.second << std::endl;

    return 0;
}

可能结果

lemon: yellow
banana: yellow

查找元素

      iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const;

// unordered_multimap::find
#include <iostream>
#include <string>
#include <unordered_map>

int main()
{
    std::unordered_multimap<std::string, std::string> mymap = {
       {"mom","church"},
       {"mom","college"},
       {"dad","office"},
       {"bro","school"} };

    std::cout << "one of the values for 'mom' is: ";
    std::cout << mymap.find("mom")->second;
    std::cout << std::endl;

    return 0;
}

输出

one of the values for 'mom' is: church

总结

容器底层实现是否有序数值是否可以重复能否更改数值查询增删
std::unordered_set哈希表否否否O(1)O(1)
std::unordered_multiset哈希表否是否O(1)O(1)
std::unordered_map哈希表否key否key否O(1)O(1)
std::unordered_multimap哈希表否key可key否O(1)O(1)
Star_ID
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++STL剖析（八）—— unordered_set和unordered_multiset的概念和使用
Edison's 小宇宙
02-14 1万+
unordered_set和unordered_multiset的介绍和使用
C++中的哈希容器unordered_map使用示例
12-31
很久以来，STL中都只提供<map>作为存放对应关系的容器，内部通常用红黑树实现，据说原因是二叉平衡树（如红黑树）的各种操作，插入、删除、查找等，都是稳定的时间复杂度，即O(log n)；但是对于hash表来说，由于无法...
STL - Unorderedset - 自定义哈希函数
weixin_34291004的博客
12-18 171
1. hash工具类 hashval.hpp #ifndef _Core_HashVal_H_ #define _Core_HashVal_H_ #include <functional> // from boost (functional/hash): // see http://www.boost.org/doc/libs/1_35...
C++哈希(无序容器，哈希表)
分享学习的知识，记录我的技术成长道路
09-18 726
C++无序容器和哈希表创建方式的介绍
STL 无序容器
浪子花梦
12-13 397
无序容器 新标准定义了 4个无序关联容器。这些容器不是使用比较运算符来组织元素，而是使用一个哈希函数和关键字类型的 ==运算符。在元素没有明显的序关系的情况下，无序容器是非常有用的。 ...
HashMap是无序的
weixin_30640769的博客
12-02 671
一、 说明 HashMap是基于哈希表Map的实现。设计初衷主要是为了解决键值（key-value）对应关联的，HashMap的优势是可以很快的根据键（key）找到该键对应的值（value），但是我们在使用的过程中需要注意一下，HashMap是一种无序的存储结构。HashMap的实现是假定元素是放在一个圆形的环上，每次put进来的元素根据其hashCode计算该元素在圆环上索引，把该元素...
unordered_map_unordered_map_
09-29
一个C++stl：unordered_map实现实例，用于了解熟悉算法。
Map(STL).rar_C++ map_c++ map_map stl_map容器
09-24
详尽的介绍了Map容器的基本用法，方便初学者掌握Map容器！
STL-map.rar_C++ map_C++map_map stl_stl map
09-22
STL中map用法详解 非常详细，有说明和可以编译的例子
Effective_STL.rar_STL_C/C++_
08-12
Effective STL
11 STL【无序容器介绍】
日月既往，不可复追
04-24 277
文章目录0 - 前言1 - 什么是无序容器2 - 无序容器种类 0 - 前言 参考：C++ STL无序容器（哈希容器）是什么？ 1 - 什么是无序容器 注意，无序容器是 C++ 11 标准才正式引入到 STL标准库中的，这意味着如果要使用该类容器，则必须选择支持 C++ 11 标准的编译器。 和关联式容器一样，无序容器也使用键值对（pair 类型）的方式存储数据。 关联式容器的底层实现采用的树存储结构，更确切的说是红黑树结构； 无序容器的底层实现采用的是哈希表的存储结构。 C++ STL 底层
STL的容器哈希表
weixin_30265171的博客
09-12 324
C++ STL中，哈希表对应的容器是 unordered_map（since C++ 11）。根据 C++ 11 标准的推荐，用 unordered_map 代替 hash_map。 与Map的区别 STL中，map 对应的数据结构是 红黑树。红黑树是一种近似于平衡的二叉查找树，里面的数据是有序的。在红黑树上做查找操作的时间复杂度为 O(logN)。而 unordered_map 对...
用哈希表实现简陋的无序set
11-30 209
#include #include #include #include using namespace std; const int hash_prime_num = 15; const unsigned int _stl_prime[] = { 2, 5, 11, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 122
【哈希表】【大/小顶堆】C++ 数据结构 无序图 优先队列
Selena的笔记本
03-19 666
C++11标准中并未加入hash_map的结构，那么哈希表的实现呢，我们用的是无序图（unordered_map）这个结构。 优先队列，顾名思义是一种特殊的队列，它的特殊之处就在于我们可以自定义队列中数据的优先级，让队列内元素按照优先级排列。
【手撕STL】unordered_set、unordered_map(用哈希表封装)
AI_ELF的博客
07-11 1367
unordered_map在线文档说明 注意：unordered_set在线文档说明注：在功能上和map、set是一样的区别在于，这两个容器遍历出来不是有序的，他们是单向迭代器 运行结果： 注：unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。总结：注： 当存储的数据没有特定说明需要排序时，一定要用unordered系列的关联式容器；当需要存储的序列为有序时，应该选用ordered系列的关联式容器对于两个数据元素的关键字 ki和kj (i != j)，有ki !=kj ，但有：
哈希表和有序表
qhu1600417010的博客
04-30 599
aaa哈希表哈希表的各种操作有序表 哈希表 哈希表在使用层面上可以理解为一种集合结构；也可以叫做无序表 如果只有key，没有伴随数据value，可以使用hashset结构，C++中叫做unordered_set； 如果既有key，也有value，可以使用hashmap结构，C++中叫做unordered_map； 哈希表的各种操作 增/改 删除 查找 增删改查的时间都是常数级别O(1)的，与数据量无关 哈希表在存储数据的时候，若储存的数据类型是基本类型，哈希表是按值来传递的，就是说哈希表直接储存这个基
哈希表、无序集合、映射的原理与实现
qq_24186017的博客
07-21 342
哈希表(Hash table)又称散列表，是一种可以通过key直接进行访问的数据结构。
数据结构学习笔记（七）：哈希表（Hash Table）
文程序公子的博客
06-25 1677
1 哈希表的含义与结构特点 1.1 哈希（Hash）即无序 哈希表（Hash Table）更直观的中文名字是散列表，存储在里面的元素不是单个的，而是成对的，这就是我们熟悉的键值对（key-value pair）。Java中的Map（映射）、Python中的Dictionary（字典）以及NoSQL（非关系型数据库）采用的都是这种存储方式。 “数据结构学习笔记”系列的前6篇文章介绍的线性表型结构（链表、栈、队列）、数组型结构（数组、基于数组的字符串）和树型结构（二叉树）都有一个共同的特点，就是它们都要保
LeetCode刷题 --哈希表 与 字符串【2020第一版】
"禅达牛车"的博客
06-17 343
1.哈西表 1.1 哈希表概述 \quad哈西表(hash table,也叫散列表)，是根据关键字值(key)直接进行访问的数据结构，它通过把关键字映射到表中一个位置(数组下标)来直接访问，以加快查找关键字值的速度。这个映射函数叫做哈西(散列)函数，存放记录的数组叫做哈西（散列）表。 //哈西排序： 实践复杂度O(表长+n) n为元素个数 int random[10] = {999,1,44,555,666,8,12,902,11,520}; //在0-1000中的随意取值 int hash_map[100
c++哈希表unordered_set unordered_map
最新发布
10-12
C++中的哈希表unordered_set和unordered_map是什么？ unordered_set和unordered_map都是C++ STL中的容器，它们都是基于哈希表实现的。unordered_set是一个集合容器，其中的元素是唯一的，而unordered_map是一个关联容器，其中的元素是键值对，每个键只能出现一次。 unordered_set和unordered_map的底层实现都是哈希表，因此它们的查找、插入和删除操作都非常高效，时间复杂度为O(1)。 unordered_set和unordered_map的使用方法与其他STL容器类似，可以使用迭代器遍历元素，也可以使用各种算法对其进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值