C++中常见容器总结

快来打我* 2021-09-20 22:04 324阅读 0赞

> ### 文章目录 ###
> 
>  *   *  string用法
>      *  vector用法
>      *  set用法
>      *  map用法
>      *  queue用法
>      *  priority\_queue用法

C++中的STL库中有许多好用的工具，通过它们能够快速的实现数据的储存和常见的运算，下面就总结一下一些常用的容器。

## string用法 ##

在C++中定义了字符串容器，要用它需要在头文件中声明`#include<string>`  
并且加上 `using namespace std;`  
a)声明

#include<cstdio>
    #include<string>
    using namespace std;
    int main(){ 
        string str1 ="abc";
        string str2 = "def";
        str1 += str2 // +可以作为字符串的连接符，结果是str1 ="abcdef"
        //字符串可以直接用比较运算符比较，比较的是字典顺序
        if(str1 > str2){ 
    	   printf("yes")
        }
        else{ 
    	   printf("no");
        }
    }

需要注意的是，如果要直接读入或者输出一个string类型的，只能够用cin和cout。要用printf输出的话，要转化为char\*,用c\_str()方法。printf("%s",str.c\_str());

b)访问

//通过下标方式访问或者通过迭代器来访问 
    	for(int i=0; i < str.size();i++){ 
    		printf("%c",str[i]);
    	} 
    	string::iterator it = str.begin();
    	for(it; it < str.end(); it++){ 
    		printf("%c",*it);
    	}

需要注意str.end()不是指字符串的最后一个元素的地址，而是指字符串最后一个元素地址的下一个地址，end()是作为迭代器的末尾标志。

c)插入

string str = "abc"
    	string str1 ="def";
    	//法一：insert(pos,str)
    	str.insert(2,str1);	//在下标为2的地方插入str1
    	printf("%s",str.c_str()); //结果是abdefc
    	//法二:insert(it,it1,it2)， 
    	str.insert(str.begin()+1,str1.begin(),str1.end());
    	printf("%s\n",str.c_str());//结果是adefbc

d)删除

string str ="abc";
    	//删除单个元素,erase(it)
    	str.erase(str.begin()+1);
    	//删除多个元素，法一:erase(it,it1)//it代表指针
    	str.erase(str.begin()+2,str.end());
    	//法二:erase(pos,len)
    	str.erase(1,2);

e)查找

string str ="abcbc";
    	int pos = str.find("bc")//返回查找字符串第一次在源串中的位置
    	int pos1 = str.find("bc",2)//从源串的第2个位开始查找
    	//当没有找到时，会返回 string::npos,其数值可以代表-1

f)替换 replace()

string str="abc";
    	string str1 ="def";
    	//replace(pos.len,str1)，把起始位置为pos，长度为len的源子串替换为str1，形成一个新字符串
    	str.replace(0,2,str1)//结果为defc
    	//replace(it1,it2,str1),指定替换范围，注意是左闭右开区间
    	str.replace(str.begin(),str.begin()+2,str1)//结果为defc

## vector用法 ##

vector可以将它看为一个变长的数组，而且里面可以存储任意类型的元素。比如数字，字符串，结构体，其他的容器等。需要在头文件上添加`#include<vector>` 并且要添加`using namespace std;`

a)声明,添加元素，遍历  
`声明:vector<type> name,若type是一个容器，要在>后加上一个空格，vector<vector<int> >vec.这是为了和移位运算符区分开`  
`末尾添加:ve.push_back()`  
`遍历:ve[i]或者用迭代器`  
例子:

#include<iostream>
    #include<vector>
    using namespace std;
    /* C++中STL标准模板库中vector的用法 */
    int main() { 
    	vector<int> ve;//声明一个向量，里面可以存储int类型 
    	for(int i=0; i < 5; i++){ 
    		ve.push_back(i);//用push_back()方法向容器中添加元素 
    	}
    	for(int i=0; i < ve.size();i++){ 
    		//访问方式1：通过下标访问，类似于数组
    		cout<<ve[i]; 
    	}
    	//访问方式2：通过迭代器
    	for(vector<int>::iterator it = ve.begin();it != ve.end(); it++ ){ 
    		cout<<*it;
    	}
    	return 0;
    }

b)大小，删除，插入,清除  
`容器大小:ve.size()`  
`删除末尾元素: ve.pop_back():`  
`清除:ve.erase()`

int size  = ve.size();//给出容器的大小 
    	ve.pop_back();//删除最后一个元素
    	ve.insert(ve.begin(),10);//在0位置插入10，注意这里的参数是指针 
    	ve.erase(ve.begin())+2);//清除位置是2的元素
    	ve.erase(ve.begin(),ve.begin()+3)//清除[0,3)的元素
    	ve.clear();//清除所有元素，等价于ve.erase(ve.begin(),ve.end())

## set用法 ##

set在数学中是集合的意思，在C++中集合有一下特征：内部有序且不含重复元素。使用方法，要加上`#include<set>`和`using namespace std;`  
a)声明,访问,添加元素  
`声明:set<type> name//注意，当set中的元素为容器的时候，要在>后加一个空格。set<vector<iint> >name 和移位运算区别`  
`添加元素 insert()`  
`遍历只能迭代器`

#include<iostream>
    #include<set>
    using namespace std;
    int main(){ 
    	//声明一个set 
    	set<int>s;
    	//向set中添加元素 
    	s.insert(3);
    	s.insert(5);
    	s.insert(1);
    	//set中的元素遍历只能够是通过迭代器来实现 
    	set<int>::iterator it = s.begin();
    	for(it;it != s.end(); it++){ 
    		cout<<*it;
    	}
    } //输出的结果是有序的，为1,3,5

b)删除，查找，清空  
`删除:erase(it),erase(value),erase(fist,end)`  
`查找:find(value)`  
`清空 :clear()`

#include<iostream>
    #include<set>
    using namespace std;
    int main(){ 
    	//声明一个set 
    	set<int>s;
    	//向set中添加元素 
    	s.insert(3);
    	s.insert(5);
    	s.insert(1);
    	s.insert(4);
    	s.insert(9); 
    	//删除单个元素，erase(it),it为所需要删除元素的迭代器
    	//s.find(value)，find()是找到set中值为value的迭代器 
    	s.erase(s.find(1));
    	//删除单个元素,erase(value)
    	s.erase(3);
    	//删除多个元素,erase(first,end),其中first，end为要删除的区间的起始迭代器
    	//范围是[first,end) 
    	s.erase(s.find(5),s.end());//删除了5,9 
    	set<int>::iterator it = s.begin();
    	//输出的结果为4
    	for(it;it != s.end(); it++){ 
    		cout<<*it;
    	}
    	//清空集合中的元素 
    	s.clear();
    	cout<<s.size();//输出为0
    	
    }

## map用法 ##

map可以将任何基本类型（包括STL容器）映射到任何基本类型(包括STL容器)，  
在使用时要加上头文件`#include<map>`以及`using namespace std;`  
a)声明，赋值，遍历

#include<iostream>
    #include<map>
    using namespace std;
    int main(){ 
    	//声明map
    	map<int,string>st;
    	//赋值，和数组类似
    	st[0] ="str1";
    	st[1] ="str3";
    	st[2] ="str2";
    	//通过键名来遍历值 
    	for(int i=0; i<st.size(); i++){ 
    		cout<<st[i]<<endl;
    	}
    	//用迭代器来遍历,it->first代表键，it->second代表值 
    	map<int,string>::iterator it = st.begin();
    	for(it;it !=st.end(); it++ ){ 
    		cout<<it->first<<"=>"<<it->second<<endl; 
    	}
    }

b)查找，删除，清空

//find()函数，找出对应元素的迭代器
    	map<int,string>::iterator it = st.find(0);
    	cout<<it->first<<" "<<it->second<<endl; 
    	//删除单个元素,erase(it)
    	st.erase(st.find(0)); 
    	//删除单个元素,erase(键名)
    	st.erase(1);
    	//删除一个范围内的元素
    	st.erase(st.begin(),st.end());//相当于st.clear()
    	cout<<st.size();

## queue用法 ##

队列（queue）作为一种先进进先出的数据结构，有着广泛的用途。比如在广度优先搜索中，就会用到queue，下面总结一下queue的常见操作  
1)`插入,访问,删除`

#include<cstdio>
    #include<queue>
    using namespace std;
    int main(){ 
    	queue<int>q;//声明一个队列q；
    	q.push(1);
    	q.push(2);
    	q.push(3); //push操作：向队尾添加元素
    	if(!q.empty()){  //进行pop,front操作前先判断队列是否为空 
    		int head = q.front(); //front操作:访问队首元素
    		int tail =  q.back();//back操作：访问队尾元素 
    		printf("%d %d\n",head,tail); //结果是1 3
    		q.pop();//pop操作，删除队首的元素 
    		printf("%d\n",q.front());//再次访问队首，结果为2
    	}	
    }

## priority\_queue用法 ##

priority\_queue又叫做优先队列，它的底层是通过堆来实现的。保证了队首的元素一定是优先级最高的。优先队列没有front()和back()操作，只能够通过top()来访问队首的元素  
1)`声明，定义`

#include<queue>
    priority_queue<int> pq;

2)`插入,访问`

pq.push(1);
    pq.push(2);
    pq.push(3); 
    printf("%d",pq.top());//结果为3

关于优先级的问题  
默认情况下，优先队列是将最大的元素放在队首的，所谓最大元素，对于普通的类型如int,double等，就是数值大的优先级高，对于char类型的话，就是按照字典大小。  
其实优先队列一般有两种声明方式

priority_queue<int>
    priority_queue<int,vector<int>,less<int>>

这两种声明方式是等价的，对于第二种声明方式,第一个参数int说明队列中存放的数据类型是int性，`vector<int>`是堆的底层实现（优先队列是通过堆来实现的），后面的`less<int>`就指明了优先级，`less<int>`表明将优先级高的放在队首，与之相反的是`greater<int>`，表明将优先级低的放在队首。  
对于非一般类型的数据，比如结构体，又该如何设置优先级呢？

#include<cstdio>
    #include<queue>
    using namespace std;
    struct student{ 
    	int id;
    	int score;
    	//设置一个函数，对student类型的操作符<进行重载
    	friend bool operator < (student a,student b){ 
    		return a.score < b.score;//将分数高的放在队首
    	}
    	//构造函数
    	student(int _id,int _score):id(_id),score(_score){ } 
    };
    int main(){ 
    	student a = student(1,90);
    	student b = student(2,80);
    	priority_queue<student> pq;
    	pq.push(a);
    	pq.push(b);
    	student t = pq.top();
    	printf("%d:%d",t.id,t.score);
    	
    }