map：
Map是c++的一个标准容器，她提供了很好一对一的关系，在一些程序中建立一个map可以起到事半功倍的效果，总结了一些map基本简单实用的操作！
1. map最基本的构造函数；
map<string , int >mapstring; map<int ,string >mapint;
map<sring, char>mapstring; map< char ,string>mapchar;
map<char ,int>mapchar; map<int ,char >mapint；
2. map添加数据；
map<int ,string> maplive;
1.maplive.insert(pair<int,string>(102,"aclive"));
2.maplive.insert(map<int,string>::value_type(321,"hai"));
3, maplive[112]="April";//map中最简单最常用的插入添加！
3，map中元素的查找：
find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。 map<int ,string >::iterator l_it;;
l_it=maplive.find(112);
if(l_it==maplive.end())
cout<<"we do not find 112"<<endl;
else cout<<"wo find 112"<<endl;
4,map中元素的删除：
如果删除112；
map<int ,string >::iterator l_it;;
l_it=maplive.find(112);
if(l_it==maplive.end())
cout<<"we do not find 112"<<endl;
else maplive.erase(l_it); //delete 112;
5,map中 swap的用法：
Map中的swap不是一个容器中的元素交换，而是两个容器交换；
For example：
#include <map>
#include <iostream>
using namespace std;
int main( )
{
map <int, int> m1, m2, m3;
map <int, int>::iterator m1_Iter;
m1.insert ( pair <int, int> ( 1, 10 ) );
m1.insert ( pair <int, int> ( 2, 20 ) );
m1.insert ( pair <int, int> ( 3, 30 ) );
m2.insert ( pair <int, int> ( 10, 100 ) );
m2.insert ( pair <int, int> ( 20, 200 ) );
m3.insert ( pair <int, int> ( 30, 300 ) );
cout << "The original map m1 is:";
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << " " << m1_Iter->second;
cout << "." << endl;
// This is the member function version of swap
//m2 is said to be the argument map; m1 the target map
m1.swap( m2 );
cout << "After swapping with m2, map m1 is:";
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << " " << m1_Iter -> second;
cout << "." << endl;
cout << "After swapping with m2, map m2 is:";
for ( m1_Iter = m2.begin( ); m1_Iter != m2.end( ); m1_Iter++ )
cout << " " << m1_Iter -> second;
cout << "." << endl;
// This is the specialized template version of swap
swap( m1, m3 );
cout << "After swapping with m3, map m1 is:";
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << " " << m1_Iter -> second;
cout << "." << endl;
}6.map的sort问题：
Map中的元素是自动按key升序排序,所以不能对map用sort函数：
For example：
#include <map>
#include <iostream>
using namespace std;
int main( )
{
map <int, int> m1;
map <int, int>::iterator m1_Iter;
m1.insert ( pair <int, int> ( 1, 20 ) );
m1.insert ( pair <int, int> ( 4, 40 ) );
m1.insert ( pair <int, int> ( 3, 60 ) );
m1.insert ( pair <int, int> ( 2, 50 ) );
m1.insert ( pair <int, int> ( 6, 40 ) );
m1.insert ( pair <int, int> ( 7, 30 ) );
cout << "The original map m1 is:"<<endl;
for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
cout << m1_Iter->first<<" "<<m1_Iter->second<<endl;
} The original map m1 is:
1 20
2 50
3 60
4 40
6 40
7 30
7， map的基本操作函数：
C++ Maps是一种关联式容器，包含“关键字/值”对
begin() 返回指向map头部的迭代器
clear(） 删除所有元素
count() 返回指定元素出现的次数
empty() 如果map为空则返回true
end() 返回指向map末尾的迭代器
equal_range() 返回特殊条目的迭代器对
erase() 删除一个元素
find() 查找一个元素
get_allocator() 返回map的配置器
insert() 插入元素
key_comp() 返回比较元素key的函数
lower_bound() 返回键值>=给定元素的第一个位置
max_size() 返回可以容纳的最大元素个数
rbegin() 返回一个指向map尾部的逆向迭代器
rend() 返回一个指向map头部的逆向迭代器
size() 返回map中元素的个数
swap() 交换两个map
upper_bound() 返回键值>给定元素的第一个位置
value_comp() 返回比较元素value的函数
例示：
#include <stdio.h>
#include <string.h>
#include <map>
using namespace std;
int main(int argc, char const *argv[])
{
map<int, int> my_map;
map<int ,int>::iterator iter;
/************insert*************/
my_map.insert(pair<int ,int>(1,10));
my_map.insert(pair<int ,int>(2,11));
/************print**************/
for(iter = my_map.begin();iter != my_map.end();iter++)
printf("%d\n",iter->second);
/**************find()**************/
iter = my_map.find(2);
if(iter == my_map.end())
printf("there is no such data!\n");
else
{
printf("%d\n", iter->first);
printf("%d\n", iter->second);
/*****************delete****************/
my_map.erase(iter);
}
/************print**************/
for(iter = my_map.begin();iter != my_map.end();iter++)
printf("%d\n",iter->second);
return 0;
}
set：
set集合容器实现了红黑树（Red-Black Tree）的平衡二叉检索树的的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值；另外，还得确保根节点的左子树的高度与有字数的高度相等，这样，二叉树的高度最小，从而检索速度最快。要注意的是，它不会重复插入相同键值的元素，而采取忽略处理。
平衡二叉检索树的检索使用中序遍历算法，检索效率高于vector、deque、和list的容器。另外，采用中序遍历算法可将键值由小到大遍历出来，所以，可以理解为平衡二叉检索树在插入元素时，就会自动将元素按键值从小到大的顺序排列。
构造set集合的主要目的是为了快速检索，使用set前，需要在程序头文件中包含声明“#include<set>”。
set的各成员函数列表如下:
c++ stl容器set成员函数:begin()--返回指向第一个元素的迭代器
c++ stl容器set成员函数:clear()--清除所有元素
c++ stl容器set成员函数:count()--返回某个值元素的个数
c++ stl容器set成员函数:empty()--如果集合为空，返回true
c++ stl容器set成员函数:end()--返回指向最后一个元素的迭代器
c++ stl容器set成员函数:equal_range()--返回集合中与给定值相等的上下限的两个迭代器
c++ stl容器set成员函数:erase()--删除集合中的元素
c++ stl容器set成员函数:find()--返回一个指向被查找到元素的迭代器
c++ stl容器set成员函数:get_allocator()--返回集合的分配器
c++ stl容器set成员函数:insert()--在集合中插入元素
c++ stl容器set成员函数:lower_bound()--返回指向大于（或等于）某值的第一个元素的迭代器
c++ stl容器set成员函数:key_comp()--返回一个用于元素间值比较的函数
c++ stl容器set成员函数:max_size()--返回集合能容纳的元素的最大限值
c++ stl容器set成员函数:rbegin()--返回指向集合中最后一个元素的反向迭代器
c++ stl容器set成员函数:rend()--返回指向集合中第一个元素的反向迭代器
c++ stl容器set成员函数:size()--集合中元素的数目
c++ stl容器set成员函数:swap()--交换两个集合变量
c++ stl容器set成员函数:upper_bound()--返回大于某个值元素的迭代器
c++ stl容器set成员函数:value_comp()--返回一个用于比较元素间的值的函数
1.创建set集合对象
创建set对象时，需要指定元素的类型，这一点和其他容器一样。
#include<iostream>
#include<set>
using namespace std;
int main()
{
set<int> s;
return 0;
}2..元素的插入与中序遍历
采用inset()方法把元素插入到集合中，插入规则在默认的比较规则下，是按元素值从小到大插入，如果自己指定了比较规则函数，则按自定义比较规则函数插入。使用前向迭代器对集合中序遍历，结果正好是元素排序后的结果。
#include<iostream>
#include<set>
using namespace std;
int main()
{
set<int> s;
s.insert(5); //第一次插入5，可以插入
s.insert(1);
s.insert(6);
s.insert(3);
s.insert(5); //第二次插入5，重复元素，不会插入
set<int>::iterator it; //定义前向迭代器
//中序遍历集合中的所有元素
for(it = s.begin(); it != s.end(); it++)
cout << *it << " ";
cout << endl;
return 0;
}
//运行结果：1 3 5 63.元素的方向遍历
使用反向迭代器reverse_iterator可以反向遍历集合，输出的结果正好是集合元素的反向排序结果。它需要用到rbegin()和rend()两个方法，它们分别给出了反向遍历的开始位置和结束位置。
#include<iostream>
#include<set>
using namespace std;
int main()
{
set<int> s;
s.insert(5); //第一次插入5，可以插入
s.insert(1);
s.insert(6);
s.insert(3);
s.insert(5); //第二次插入5，重复元素，不会插入
set<int>::reverse_iterator rit; //定义反向迭代器
//反向遍历集合中的所有元素
for(rit = s.rbegin(); rit != s.rend(); rit++)
{
cout << *rit << " ";
}
cout << endl;
return 0;
}
//运行结果：6 5 3 14.元素的删除
与插入元素的处理一样，集合具有高效的删除处理功能，并自动重新调整内部的红黑树的平衡。删除的对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素和清空集合。
#include<iostream>
#include<set>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
set<int> s;
s.insert(5); //第一次插入5，可以插入
s.insert(1);
s.insert(6);
s.insert(3);
s.insert(5); //第二次插入5，重复元素，不会插入
s.erase(6); //删除键值为6的元素
set<int>::reverse_iterator rit; //定义反向迭代器
//反向遍历集合中的所有元素
for(rit = s.rbegin(); rit != s.rend(); rit++)
{
cout << *rit << " ";
}
cout << endl;
set<int>::iterator it;
it = s.begin();
for(int i = 0; i < 2; i++)
s.erase(it++);
for(it = s.begin(); it != s.end(); it++)
cout << *it << " ";
cout << endl;
s.clear();
cout << s.size() << endl;
return 0;
}
/*
运行结果：
5 3 1
5
0
*/
5.元素的检索
使用find()方法对集合进行检索，如果找到查找的的键值，则返回该键值的迭代器位置；否则，返回集合最后一个元素后面的一个位置，即end()。
#include<iostream>
#include<set>
using namespace std;
int main()
{
set<int> s;
s.insert(5); //第一次插入5，可以插入
s.insert(1);
s.insert(6);
s.insert(3);
s.insert(5); //第二次插入5，重复元素，不会插入
set<int>::iterator it;
it = s.find(6); //查找键值为6的元素
if(it != s.end())
cout << *it << endl;
else
cout << "not find it" << endl;
it = s.find(20);
if(it != s.end())
cout << *it << endl;
else
cout << "not find it" << endl;
return 0;
}
/*
运行结果：
6
not find it
*/6.下面这种方法也能判断一个数是否在集合中：
#include <cstdio>
#include <set>
using namespace std;
int main() {
set <int> s;
int a;
for(int i = 0; i < 10; i++)
s.insert(i);
for(int i = 0; i < 5; i++) {
scanf("%d", &a);
if(!s.count(a)) //不存在
printf("does not exist\n");
else
printf("exist\n");
}
return 0;
}
Vectors ：
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。为了可以使用vector，必须在你的头文件中包含下面的代码： #include <vector>
构造函数。
Vectors 包含着一系列连续存储的元素,其行为和数组类似。访问Vector中的任意元素或从末尾添加元素都可以在常量级时间复杂度内完成，而查找特定值的元素所处的位置或是在Vector中插入元素则是线性时间复杂度。
函数列表如下:
Constructors 构造函数
Operators 对vector进行赋值或比较
assign() 对Vector中的元素赋值
at() 返回指定位置的元素
back() 返回最末一个元素
begin() 返回第一个元素的迭代器
capacity() 返回vector所能容纳的元素数量(在不重新分配内存的情况下）
clear() 清空所有元素
empty() 判断Vector是否为空（返回true时为空）
end() 返回最末元素的迭代器(译注:实指向最末元素的下一个位置)
erase() 删除指定元素
front() 返回第一个元素
get_allocator() 返回vector的内存分配器
insert() 插入元素到Vector中
max_size() 返回Vector所能容纳元素的最大数量（上限）
pop_back() 移除最后一个元素
push_back() 在Vector最后添加一个元素
rbegin() 返回Vector尾部的逆迭代器
rend() 返回Vector起始的逆迭代器
reserve() 设置Vector最小的元素容纳数量
resize() 改变Vector元素数量的大小
size() 返回Vector元素数量的大小
swap() 交换两个Vector
函数详细说明
构造函数
语法:
vector();
vector( size_type num, const TYPE &val );
vector( const vector &from );
vector( input_iterator start, input_iterator end );
C++ Vectors可以使用以下任意一种参数方式构造:
无参数 - 构造一个空的vector,
数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector
vector(from) - 构造一个与vector from 相同的vector
迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).
举例,下面这个实例构造了一个包含5个值为42的元素的Vector
vector<int> v1( 5, 42 );
运算符
语法:
v1 == v2
v1 != v2
v1 <= v2
v1 >= v2
v1 < v2
v1 > v2
v[]
C++ Vectors能够使用标准运算符: ==, !=, <=, >=, <, 和 >. 要访问vector中的某特定位置的元素可以使用 [] 操作符.
两个vectors被认为是相等的,如果:
它们具有相同的容量
所有相同位置的元素相等.
vectors之间大小的比较是按照词典规则.
assign函数
语法:
void assign( input_iterator start, input_iterator end );
void assign( size_type num, const TYPE &val );
assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.
at函数
语法:
TYPE at( size_type loc );
at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素. 例如, 考虑下面的代码:
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is " << v[i] << endl;
}
这段代码访问了vector末尾以后的元素,这将可能导致很危险的结果.以下的代码将更加安全:
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is " << v.at(i) << endl;
}
取代试图访问内存里非法值的作法,at() 函数能够辨别出访问是否越界并在越界的时候抛出一个异常out_of_range.
back 函数
语法:
TYPE back();
back() 函数返回当前vector最末一个元素的引用.例如:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
cout << "The first element is " << v.front()
<< " and the last element is " << v.back() << endl;
这段代码产生如下结果:
The first element is 0 and the last element is 4
begin 函数
语法:
iterator begin();
begin()函数返回一个指向当前vector起始元素的迭代器.例如,下面这段使用了一个迭代器来显示出vector中的所有元素:
vector<int> v1( 5, 789 );
vector<int>::iterator it;
for( it = v1.begin(); it != v1.end(); it++ )
cout << *it << endl;
capacity 函数
语法:
size_type capacity();
capacity() 函数 返回当前vector在重新进行内存分配以前所能容纳的元素数量.
clear 函数
语法:
void clear();
clear()函数删除当前vector中的所有元素.
empty 函数
语法:
bool empty();
如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false.例如,以下代码清空一个vector,并按照逆序显示所有的元素:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
while( !v.empty() ) {
cout << v.back() << endl;
v.pop_back();
}
end 函数
语法:
iterator end();
end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,如果你要访问末尾元素,需要先将此迭代器自减1.
erase 函数
语法:
iterator erase( iterator loc );
iterator erase( iterator start, iterator end );
erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器.例如:
// 创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
int size = alphaVector.size();
vector<char>::iterator startIterator;
vector<char>::iterator tempIterator;
for( int i=0; i < size; i++ )
{
tartIterator = alphaVector.begin();
alphaVector.erase( startIterator );
// Display the vector
for( tempIterator = alphaVector.begin(); tempIterator != alphaVector.end(); tempIterator++ )
cout << *tempIterator;
cout << endl;
}
这段代码将会显示如下输出:
BCDEFGHIJ
CDEFGHIJ
DEFGHIJ
EFGHIJ
FGHIJ
GHIJ
HIJ
IJ
J
front 函数
语法:
TYPE front();
front()函数返回当前vector起始元素的引用
get_allocator 函数
语法:
allocator_type get_allocator();
get_allocator() 函数返回当前vector的内存分配器.在STL里面一般不会调用new或者alloc来分配内存,而且通过一个allocator对象的相关方法来分配.
示例:vectorv3( 3, 1, v2.get_allocator( ));//把V2的内存分配器作为一个参数参与构造V3。这样，它们两个用一个内存分配器了。
insert 函数
语法:
iterator insert( iterator loc, const TYPE &val );
void insert( iterator loc, size_type num, const TYPE &val );
void insert( iterator loc, input_iterator start, input_iterator end );
insert() 函数有以下三种用法:
在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,
在指定位置loc前插入num个值为val的元素
在指定位置loc前插入区间[start, end)的所有元素 .
举例:
//创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
//插入四个C到vector中
vector<char>::iterator theIterator = alphaVector.begin();
alphaVector.insert( theIterator, 4, 'C' );
//显示vector的内容
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )
cout << *theIterator;
这段代码将显示:
CCCCABCDEFGHIJ
max_size 函数
语法:
size_type max_size();
max_size() 函数返回当前vector所能容纳元素数量的最大值(译注:包括可重新分配内存).
pop_back
语法:
void pop_back();
pop_back()函数删除当前vector最末的一个元素,例如:
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
int size = alphaVector.size();
vector<char>::iterator theIterator;
for( int i=0; i < size; i++ ) {
alphaVector.pop_back();
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )
cout << *theIterator;
cout << endl;
}
这段代码将显示以下输出:
ABCDEFGHI
ABCDEFGH
ABCDEFG
ABCDEF
ABCDE
ABCD
ABC
AB
A
push_back 函数
语法:
void push_back( const TYPE &val );
push_back()添加值为val的元素到当前vector末尾
size 函数
语法:
size_type size();
size() 函数返回当前vector所容纳元素的数目
string：
1.string和char *的区别
(1)string是一个类，char *是一个指向字符的指针。
(2)string不用考虑内存释放和越界。
(3)string提供了一系列字符串操作函数：find，copy，erase，replace，insert等。
2.string的构造函数及遍历
#include <iostream>
#include <string>
using namespace std;
int main()
{
/* 字符串的四种构造方法 */
string s1 = "hello";
string s2("haha");
string s3 = s2;
string s4(5,'a');
cout << s4 << endl; //aaaaa
/* 字符串遍历的方法 */
//1.数组方式
for(int i=0;i<s1.length();i++)
{
cout << s1[i] << " ";
}
cout << endl;
//2.迭代器
for(string::iterator it = s1.begin();it!=s1.end();it++)
{
cout << *it << " ";
}
cout << endl;
return 0;
}3.string类存取字符的操作
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1 = "hello";
for(int i=0;i<s1.length();i++)
{
cout << s1.at(i) << " "; //抛出异常
}
return 0;
}4.连接字符串
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1 = "hello";
string s2 = "world";
s1 = s1 + s2;
cout << s1 << endl;
string s3 = "hello";
string s4 = "c++";
s3.append(s4);
cout << s3 << endl;
return 0;
}6.字符串查找和替换（重点）
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1 = "hello Java,hello C#,hello C++,hello Python";
//第一次出现hello的index
int index = s1.find("hello",0);
cout << index << endl;
//求hello出现的次数以及每一次出现的数组下标
int offindex = s1.find("hello",0);
while (offindex != string::npos)
{
cout << offindex << endl;
offindex = offindex+1;
offindex = s1.find("hello",offindex);
}
return 0;
}7.string的典型操作：删除和插入
(1)删除操作：
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
string s1 = "hello1 hello2 hellol";
string::iterator it = find(s1.begin(),s1.end(),'1');
if (it != s1.end())
{
s1.erase(it);
}
cout << s1 << endl;
s1.erase(s1.begin(),s1.end()); //全部删除
cout << s1.length() << endl;
return 0;
}(2)插入操作：
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
string s1 = "aaa";
s1.insert(0,"hahaha"); //头部插入
s1.insert(s1.length(),"---"); //尾部插入
cout << s1 << endl;
return 0;
}
8.大小写转换
#include <stdio.h>
#include <string.h> //strlen
#include <ctype.h> //toupper
using namespace std;
int main()
{
int i;
char s[] = "HELLO WORLD";
for(i=0;i<strlen(s);i++)
{
s[i] = tolower(s[i]);
}
printf("%s\n",s);
return 0;
}
扫一扫
455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
