C++Primer第五版 习题答案 第十一章关联容器

最新推荐文章于 2023-02-19 15:25:35 发布
最新推荐文章于 2023-02-19 15:25:35 发布
阅读量670 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24898229/article/details/123796603
版权

11.1

map是关联式容器，元素式按关键字保存和访问的；
vector是顺序容器，其元素是按照它在容器中的位置来保存和访问的；

11.2

list：插入较多情况；
vector：动态数组；
deque：需要头部和尾部增删的情况；
map：字典；
set：添加忽略关键字；

11.3

#include<iostream>
#include<string>
#include<map>

using namespace std;

int main() {
	map<string, size_t> word_count;
	string words;
	while (cin>>words)
	{
		++word_count[words];
	}
	for (const auto &s : word_count)
		cout << s.first << " occurs  " << s.second << ((s.second > 1) ? " times " : " time ") << endl;
	return 0;
}

11.4

#include<iostream>
#include<string>
#include<map>
#include<algorithm>
#include<set>

using namespace std;

int main() {
	map<string, size_t> word_count;
	set<string>exclude{ "you","i" };
	string words;
	
	while (cin>>words)
	{
		words.erase(find_if(words.begin(), words.end(), ::ispunct), words.end()); //删除单词后面的标点
		for_each(words.begin(), words.end(), [](char& c) {c = tolower(c); }); //单词转换为小写
		if(exclude.find(words)==exclude.end()) //忽略部分单词
			++word_count[words];
	}
	for (const auto &s : word_count)
		cout << s.first << " occurs  " << s.second << ((s.second > 1) ? " times " : " time ") << endl;
	return 0;
}

11.5

set中只有关键字；
map包括关键字-值对；

11.6

set关联式容器，查找较快；
list顺序容器，查找关键字与容器的大小有关；

11.7

#include<iostream>
#include<string>
#include<map>
#include<vector>

using namespace std;

int main() {
	map<string, vector<string>>	family;
	string first_name, last_name;
	cin >> last_name;
	while (cin >> first_name)
	{
		family[last_name].push_back(first_name);
	}
	for (const auto f : family) {
		cout << f.first << endl;
		for (const auto s : f.second)
			cout << s << " ";
		cout << endl;
	}
	return 0;
}

11.8

效率更高，不用遍历判断重复；

#include<iostream>
#include<string>
#include<vector>

using namespace std;

int main() {
	vector<string>vs;
	string s;
	while (cin >>s)
	{
		if (find(vs.begin(), vs.end(), s) == vs.end())
			vs.push_back(s);
	}
	for (const auto s : vs)
		cout << s << " ";
	cout << endl;
	return 0;
}

11.9

map<string,list<size_t>> words_line;

11.10

对于有序容器必须定义元素的比较方法，默认<;
vector<int>::iterator 可以，因为定义了<;
list<int>::iterator不可以，未定义<;

11.11

#include <set>
#include <iostream>
#include <string>
#include "../ch07_Classes/Sales_data_ex26.h"

bool compareIsbn(const Sales_data &sales_data1, const Sales_data &sales_data2)
{
	return sales_data1.isbn() < sales_data2.isbn();
}

int main()
{
	using COMPAREISBN = bool (*)(const Sales_data &sales_data1, const Sales_data &sales_data2);
	// std::multiset<Sales_data, decltype(compareIsbn)*> bookstore(compareIsbn);
	std::multiset<Sales_data, COMPAREISBN> bookstore(compareIsbn);
	return 0;
}

11.12

#include<iostream>
#include<string>
#include<vector>
#include<utility>

using namespace std;

int main() {
	vector<pair<string, int>>vp;
	int i;
	string s;
	while (cin>>s>>i)
	{
		//vp.push_back(pair<string, int>(s, i));
		//vp.push_back({ s,i });
		vp.push_back(make_pair(s, i));
		//vp.emplace_back(s, i);

	}
	for (const auto p : vp)
		cout << p.first << " " << p.second << endl;
	return 0;
}

11.13

#include<iostream>
#include<string>
#include<vector>
#include<utility>

using namespace std;

int main() {
	vector<pair<string, int>>vp;
	int i;
	string s;
	while (cin>>s>>i)
	{
		//vp.push_back(pair<string, int>(s, i));
		//vp.push_back({ s,i });
		vp.push_back(make_pair(s, i));
		//vp.emplace_back(s, i);

	}
	for (const auto p : vp)
		cout << p.first << " " << p.second << endl;
	return 0;
}

11.14

#include<iostream>
#include<string>
#include<map>
#include<vector>
#include<utility>

using namespace std;

int main() {
	map<string, vector<pair<string, string>>>	family;
	string first_name, last_name, birthday;
	cin >> last_name;
	while (cin >> first_name >> birthday)
	{
		family[last_name].push_back(make_pair(first_name, birthday));
		for (const auto f : family) {
			cout << f.first << endl;
			for (const auto s : f.second)
				cout << s.first << " " << s.second << endl;
		}
		return 0;
	}
}

11.15

mapped_type: vector<int>
key_type: int;
value_type: pair<const int,vector<int>>

11.16

#include<iostream>
#include<string>
#include<map>

using namespace std;

int main() {
	map<int, string> m = { {1,"aa" } };
	auto m_iter = m.begin();
	m_iter->second = "bb";
	cout << m_iter->first << " " << m_iter->second << endl;
	return 0;
}

11.17

copy(v.begin(), v.end(), inserter(c, c.end())); //合法
copy(v.begin(), v.end(), back_inserter(c)); //非法,set中没有push_back()
copy(c.begin(), c.end(), inserter(v, v.end())); //合法
copy(c.begin(), c.end(), back_inserter(v)); //合法

11.18

map<string,size_t>::const_iterator map_it =word_count.cbegin();

11.19

using COMPAREISBN = bool (*)(const Sales_data &sales_data1, const Sales_data &sales_data2);
// std::multiset<Sales_data, decltype(compareIsbn)*> bookstore(compareIsbn);
std::multiset<Sales_data, COMPAREISBN> bookstore(compareIsbn);
std::multiset<Sales_data, COMPAREISBN>::iterator bookstore_iter = bookstore.begin();

11.20

使用下标更加简单；

#include<iostream>
#include<string>
#include<map>
#include<utility>

using namespace std;

int main() {
	map<string, size_t>word_count;
	string word;
	while (cin>>word)
	{
		pair<map<string, size_t>::iterator, bool> ret = word_count.insert({ word,1 });
		if (!ret.second)
			++ret.first->second;
	}

	for (const auto s : word_count)
		cout << s.first << " " << s.second << endl;
	return 0;
}

11.21

word_count.insert({word, 0})//得到insert的返回值pair
word_count.insert({word, 0}).first//得到map的迭代器
word_count.insert({word, 0}).first->second//map中size_t的值
++word_count.insert({word, 0}).first->second//递增该值

11.22

#include<iostream>
#include<string>
#include<map>
#include<utility>
#include<vector>

using namespace std;

int main() {
	map<string, vector<int>> m1;
	pair<map<string, vector<int>>::iterator, bool> ret = m1.insert({ "aaaa",{1,2,3,4,5}});
	return 0;
}

11.23

#include<iostream>
#include<string>
#include<vector>
#include<utility>
#include<map>
#include<algorithm>

using namespace std;

int main() {
	multimap<string, vector<string>>	family;
	string first_name, last_name;
	vector<string>vs;
	cin >> last_name;
	while (cin>>first_name)
	{
		vs.push_back(first_name);
	}
	family.insert({ last_name,vs });

	for (const auto f : family) {
		cout << f.first << endl;
		for (const auto s : f.second)
			cout << s << " ";
		cout << endl;
	}
	return 0;
}

11.24

向m中添加一个关键字为0的元素，并将其值初始化为1；

11.25

将容器第一个元素赋值为1；

11.26

可以用key_type对一个map进行下标操作；
下标操作返回mapped_type;

#include<iostream>
#include<string>
#include<map>

using namespace std;

int main() {
	map<int, string>m1 { {1, "dasda"} };
	map<int, string>::key_type i1 = 1;
	map<int, string>::mapped_type s1;
	s1 = m1[i1];
	cout << i1 << " " << s1 << endl;
	return 0;
}

11.27

统计该元素有多少关键字用count
查看特定元素是否在容器内用find；

11.28

#include<iostream>
#include<string>
#include<map>
#include<vector>

using namespace std;

int main() {
	map<string, vector<int>>m1{ {"aa",{1,2,3}} };
	map<string, vector<int>>::iterator i_iter = m1.find("aa");
	return 0;
}

11.29

lower_bound和upper_bound会返回相等的迭代器——都指向给定关键字的插入点，能保持容器中元素顺序的插入位置；
equal_range返回一个pair，pair中两个迭代器都指向元素可以插入的位置；

11.30

第一个迭代器的解引用后得到的书名；

11.31

#include<iostream>
#include<string>
#include<map>


using namespace std;

int main() {
	multimap<string, string>m{ {"a","abc"},{"a","avb"} };
	auto cnt = m.count("a");
	cout << cnt << endl;
	while (cnt)
	{
		m.erase(m.find("a"));
		--cnt;
	}
	for (const auto & s : m)
		cout << s.first << " " << s.second << endl;
	return 0;
}

11.32

#include<iostream>
#include<string>
#include<map>
#include<vector>

using namespace std;

int main() {
	multimap<string, string>m{ {"a","abc"},{"a","avb"},{"b","dasdsa"},{"b","sdad"},{"c","fdsdfds"}};
	map<string, vector<string>> m_ordered;
	for (const auto p : m)
		m_ordered[p.first].push_back(p.second);

	for (const auto& p : m_ordered)
	{
		cout << p.first << endl;
		for (const auto s : p.second)
			cout << s << " ";
		cout << endl;
	}
	return 0;
}

11.33

#include <map>
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>

using namespace std;

map<string, string> buildMap(ifstream &map_file)
{
	map<string, string> trans_map;
	string key;
	string value;
	while(map_file >> key && getline(map_file, value))
		if(value.size() > 1)
			trans_map[key] = value.substr(1);
		else
			throw runtime_error("no rule for " + key);
	return trans_map;
}

const string &transform(const string &s, const map<string, string> &m)
{
	auto map_it = m.find(s);
	if(map_it != m.cend())
		return map_it->second;
	else
		return s;
}

void word_tranform(ifstream &map_file, ifstream &input)
{
	auto trans_map = buildMap(map_file);
	// for(const auto p : trans_map)
	// 	cout << p.first << "->" << p.second << endl;
	string text;
	while(getline(input, text))
	{
		istringstream stream(text);
		string word;
		bool firstword = true;
		while(stream >> word)
		{
			if(firstword)
				firstword = false;
			else
				cout << " ";
			cout << transform(word, trans_map);
		}
		cout << endl;
	}
}

int main()
{
	ifstream map_file("word_transformation.txt"), input("word_transformation_bad.txt");
	word_tranform(map_file, input);

	return 0;
}

11.34

当map中没有这个元素时会插入元素，与预期不符；

11.35

在这里没有影响，如果关键字出现多次，使用下标会重复赋值，最后保存的是最后一个值，使用insert只插入第一个；

11.36

value.size() > 1 为false，将会抛出异常“no rule for” + key；

11.37

无序容器会有更好地平均性能；

11.38

单词计数程序；

#include<iostream>
#include<unordered_map>
#include<string>

using namespace std;

int main()
{
	unordered_map<string, size_t> word_count;
	string word;
	while (cin>>word)
	{
		++word_count[word];
	}
	for (const auto& w : word_count)
		cout << w.first << " occurs " <<w.second<< ((w.second > 1) ? " times" : " time") << endl;
	return 0;
}

单词转换程序

#include <unordered_map>
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>

using namespace std;

unordered_map<string, string> buildMap(ifstream &map_file)
{
	unordered_map<string, string> trans_map;
	string key;
	string value;
	while(map_file >> key && getline(map_file, value))
		if(value.size() > 1)
			trans_map[key] = value.substr(1);
		else
			throw runtime_error("no rule for " + key);
	return trans_map;
}

const string &transform(const string &s, const unordered_map<string, string> &m)
{
	auto map_it = m.find(s);
	if(map_it != m.cend())
		return map_it->second;
	else
		return s;
}

void word_tranform(ifstream &map_file, ifstream &input)
{
	auto trans_map = buildMap(map_file);
	// for(const auto p : trans_map)
	// 	cout << p.first << "->" << p.second << endl;
	string text;
	while(getline(input, text))
	{
		istringstream stream(text);
		string word;
		bool firstword = true;
		while(stream >> word)
		{
			if(firstword)
				firstword = false;
			else
				cout << " ";
			cout << transform(word, trans_map);
		}
		cout << endl;
	}
}

int main()
{
	ifstream map_file("word_transformation.txt"), input("word_transformation_bad.txt");
	word_tranform(map_file, input);

	return 0;
}
Perz_01
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ Primer习题集(第五版)
12-08
C++ Primer习题集(第五版) , 带目录完整版。 --------------------------------------------------------------------------- 目录 第1章............................................................ 1 练习1.1 ...
C++_容器小练习
sjjdjjxjs的博客
05-18 342
* 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作 * 员工信息有: 姓名 工资组成；部门分为：策划、美术、研发 * 随机给10名员工分配部门和工资 * 通过multimap进行信息的插入 key(部门编号) value(员工) * 分部门显示员工信息 创建10名员工，放到vector中 遍历vector容器，取出每个员工，进行随机分组 分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中 ..
Leetcode基础刷题记录（顺序式容器）（C++）
weixin_43220073的博客
04-06 250
知识结构和配套习题都来自于b站up主：爱学习的饲养员。 1.数组 在连续的内存空间中，存储一组相同类型的元素。 区分元素和索引（索引是相对第一个元素的距离）。 访问元素 搜索元素 添加元素 删除元素 O(1) O(1) O(N) O(N) 在C++容器库中 vector，能存放任意类型的动态数组 不是在原空间之后续接新空间，而是找更大的内存空间，将原数据拷贝到新空间，释放原空间 swap()交换vector对象，可以动态压缩数组空间 reserve()预留空间 例题： 283 移动
c++ primer 第11章 关联容器 练习
qq_44741516的博客
03-15 1088
练习11.1 描述map和vector的不同。 map是个关联容器，vector是顺序容器。 练习11.2 分别给出最适合使用list、vector、deque、map以及set的例子。 list : anytime when a doubly-linked list is required. vector : anytime when a dynamic array is required. deque : An answer from SO. map .
C++练习题
qq_43343275的博客
10-10 1026
一 1.写出64位系统环境下，以下数据类型所占字节数 char 1 1 1 char* 4 8 8 int 4 4 4 double 4 8 8 long 8 4 8 long long 8 8 8 unsigned long 8 4 8 err win lin 2.改错 如下程序能不能正确输出，如果不能，让它正确输出hello字符串。 void N...
C++ primer(第五版）第11章习题答案
INFINITE POSSIBILITIES
03-29 761
第十一章　关联容器 11.1 map是关键字－值对的集合，通过关键字来查找值。 vector是对象的集合，每个对象都有一个关联的索引，它提供对该对象的访问。 11.2 list:需要在任何地方插入或删除元素。 vector:保存一些重要的关联数据，总是需要按索引查询元素。 deque:先进先出。 map:字典。 set:错误的检查。（关键字的简单集合） 11.3~1...
C++ Primer第四版【中文高清扫描版】.pdf
03-13
第11章　泛型算法 335 11.1 概述 336 11.2 初窥算法 339 11.2.1 只读算法 339 11.2.2 写容器元素的算法 341 11.2.3 对容器元素重新排序的算法 343 11.3 再谈迭代器 347 11.3.1 插入迭代器 348 11.3.2 iostream迭代器...
[C++ Primer中文版(第4版)].习题解答(1-18章完整版)
02-08
60 第十一章 泛型算法 ............................................................................................................................................... 75 第十二章 类和数据抽象 ............
C++ primer 第4版 原书+习题解答+源码 清晰pdf
10-03
C++ primer 第4版 原书+习题解答+源码 清晰pdf，非影印。 本书是久负盛名的C++经典教程引，其内容是C++大师Stanley B. Lippman丰富的实践经验和C++标准委员会原负责人Josée Lajoie对C++标准深入理解的完美结合，...
c++容器练习一
每日提升一点点
10-16 379
#include<iostream> #include<deque> #include<vector> #include<string> #include<algorithm> #include<functional> using namespace std; class Play { public: string nam...
C++ Primer(第五版)|练习题答案与解析(第十一章:关联容器)
qq_24739717的博客
02-21 615
C++ Primer(第五版)|练习题答案与解析(第十一章:关联容器) 本博客主要记录C++ Primer(第五版)中的练习题答案与解析。 参考:C++ Primer C++ Primer 练习题11.1 描述map和vector的不同。 vector是顺序容器，只能存放单一类型的数据。 map是关联的容器，存放一对key-value,值表示与索引相关联的数据，这两个数据可以是不同类型。（P...
c++初试-容器（10）
貌似君子的专栏
11-04 691
#include #include #include #include #include #include #include #include using namespace std; void test_vector(); void test_deque(); void test_list(); void test_set(); void test_multiset(); void tes
C++Primer 第九章 顺序容器 习题答案
BadWomannnn的博客
02-19 140
由于list不要求对元素的随机存取，因此不用额外分配空间，也就没有capacity函数。iter指向奇数的情况下会无线循环，加入当前指向一个奇数，那么会在iteration之前插入一个奇数，然后返回指向插入的新元素的迭代器，陷入循环。容器的size是指它已经保存的元素的数目；1.begin和and指向同一个容器中的元素，或者是容器最后一个元素之后的位置，当将一个容器初始化为另一个容器的拷贝时，两个容器的容器类型和元素类型必须相同。c1,c2不能是无序容器，类型相同，必须保存相同类型的元素。
康拓展开
东风的博客
10-26 128
康拓展开 先上一道例题 eg.1 八数码问题 题目描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 input 输入初始状态，一行九个数字，空格用0表示 输出格式 只有一行，该行只有一个数字，表示从初始状态到目标状态需要的最少移动次数(测试数据中无特
C++ Primer 第五版 第十一章 练习题编程题目答案
Coding home - 漂流瓶jz
06-04 372
https://github.com/jzplp/Cpp-Primer-Answer 练习11.1 map用关键字索引，是一个字典。vector用整数索引，是一个列表。 练习11.2 list 链表 vector 顺序列表 deque 双端队列 map 字典 set 集合 练习11.311.3 map单词计数程序代码 练习11.411.4 去标点map单词计数程序代码 练习11.5 如果关键字有对应的值就用map，只有关键字就用set 练
C++ Primer 第九章 9.3 顺序容器的操作 练习和总结
大琪子的博客
02-08 412
9.3 顺序容器的操作 如题，这一章讲的全是顺序容器如何操作。 9.3.1 向顺序容器中添加元素 顺序容器添加元素的操作如下： 因为array的大小是固定了，所以这些操作是和array无关的。 需要注意的点： 1.如果容器有push_back,push_front这样的函数，表示这个容器在头部或者尾部添加元素时，效率较高。比如vector有push_back，所以在尾部添加元素效率很高，但是如果...
【C++】vector的使用与题目练习
weixin_60478154的博客
11-25 2049
【C++】vector的使用
c++学习之容器案例学习
weixin_42097108的博客
10-24 159
案例描述 1.公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司后，需要指派员工在哪个部门工作 2.员工的信息有：姓名，工资组成 3.部门分为：策划，美术，研发 4.随机给10名员工分配部门和工资 5.通过multimap进行信息的插入key（部门编号）value（员工） 6.分部门显示员工信息 实现步骤 1.创建10名员工，放到vector中 2.遍历vector容器，取出每个员工，进行随机分组 3.分组后，将员工部门作为key，具体员工作为value，放到multimap容器中
【c++primer第五版】第十一章习题答案
qq_51931826的博客
09-04 728
【c++primer第五版】第十一章习题答案
c++ primer第五版课后习题
最新发布
07-08
C++ Primer第五版是一本非常经典的C++编程入门教材，它包含了大量的课后习题帮助读者巩固所学的知识。这些习题涵盖了从基础到高级的各个方面，可以帮助读者提升编程能力。 如果你有具体的习题需要帮助或者想要了解...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值