STL各个容器的使用以及常用的查找

关于vector容器的使用我写在了https://blog.csdn.net/qq_42002426/article/details/108169478
所有容器都有size() empty（）方法

1.deque 双端数组，操作特点：在两端插入和删除效率都比较好，在指定位置插入，也会引起数据元素的移动。
支持随机访问
deque分段连续的内存空间

deque的几种构造方法

//构造
void test01() {
	deque<int>d;
	deque<int>d1(10, 5);
	deque<int>d2(d1.begin(), d1.end());
	deque<int>d3(d2);
	for (deque<int>::iterator d = d3.begin(); d != d3.end(); d++) {
		cout << *d << endl;
	}
}

deque的大小操作

//大小操作
void test02() {
	deque<int>d1;
	deque<int>d2;
	deque<int>d3;
	d1.assign(10, 5);//10ge 5
	d2.assign(d1.begin(), d1.end());//迭代器区间赋值
	d3 = d2;//等号赋值

	d1.swap(d2);//交换两个空间的元素
	//size empty resize 同理vector
}

插入和删除

void test03() {
	deque<int> d;
	d.push_back(100);
	d.push_front(200);
	d.push_front(300);
	d.push_back(400);
	//输出顺序应该是300 200 100 400
	//pop_front和pop_back同理相当于是删除操作
	d.clear();//清楚全部元素。。~~一袋米要扛几楼~~ 
}

2. stack容器 规则：先进后出
不能遍历 不提供迭代器 也不支持随机访问
while(!stack.empty()){
cout<< stack.top() <<endl;
stack.pop();
}

//栈是不能遍历的，只能从栈顶进行操作,不提供迭代器

void test01() {
	stack<int>s1;
	stack<int>s2(s1);

	s1.push(10);
	s1.push(20);
	s1.push(30);
	
	s1.pop();
	s1.top();//返回栈顶元素

	s1.size();//返回堆栈大小
}

3.queue队列 规则：先进先出
不能遍历 不提供迭代器 也不支持随机访问
while(!queue.empty()){
cout<< queue.fonr() <<endl;
queue.pop();
}
队列很像是排队，先排队的人先完事，后排队的后完事

//队列：在一端插入再在一端删除，先进先出
//不能遍历想输出元素的话用while（q.size()>0)cout<<q.front()<<endl;q.pop();
void test01() {
	queue<int>q;
	queue<int>q1(q);

	q.push(10);
	q.push(20);
	q.push(30);
	//输出顺序 10 20 30
	q.pop();
	q.back();//返回队尾
	q.front();//返回队受

	queue<int>q3;
	q3 = q;

	q.size();
	q.empty();
}

4.list 容器 非常常用 STL中双向链表
在任何位置插入和删除效率都比较好，因为插入和删除对于数组来说，不用移动元素
不支持随机访问，因为是非连续的内存空间，所以说为了保存结点和结点之间的前驱后继关系
需要额外的空间开销

自己提供了sort排序的方法，因为算法提供的sort是要支持随机访问的
有查找功能find()，要清楚查找基础数据类型，查找对象（提供回调）

构造及输出链表中的元素

//链表最后都指向为空
void test01() {
	list<int> l1;
	list<int> l2(l1.begin(), l1.end());
	list<int> l3(10, 1);//10个1
	list<int> l4(l3);
	l4 = l3;

	for (list<int>::iterator it = l3.begin(); it != l3.end(); it++) {
		cout << (*it) << endl;
	}
}

插入和删除 链表的删除不同于其他容器有一个remove（num）函数可移除与num想匹配的元素

void test02() {
	list<int> mylist;
	list<int> l(2, 100);
	mylist.push_back(100);
	mylist.push_front(200);
	
	mylist.insert(mylist.end(), 400);//在某个位置插入
	mylist.insert(mylist.begin(), 300);

	mylist.insert(mylist.begin(), 3, 500);//在某个位置插入3个500
	mylist.insert(mylist.begin(), l.begin(), l.end());//在某个位置插入区间内的数据

	mylist.remove(100);//删除容器内所有与100匹配的元素  erase（pos)删除pos位置的元素
}

赋值操作

//赋值操作
void test03() {
	list<int>myl;
	list<int>my2;
	myl.assign(10, 9);//10个9
	myl.swap(my2);//交换了
}

排序与翻转

//排序 翻转
void test04() {
	list<int>l;
	for (int i = 0; i < 10; i++) {
		l.push_back(i);
	}
	l.reverse();//数据反转
	l.sort();//这个是list里的排序函数默认从小到大，而不是平时用的那个算法
}

对组 pair 将两个值合并成一个值
pair<类型，类型>pair1;
make_pair(具体类型,具体类型)；

pair<T1, T2> p1;           //创建一个空的pair对象（使用默认构造），它的两个元素分别是T1和T2类型，采用值初始化。
pair<T1, T2> p1(v1, v2);   //创建一个pair对象，它的两个元素分别是T1和T2类型，其中first成员初始化为v1，second成员初始化为v2。
make_pair(v1, v2);         // 以v1和v2的值创建一个新的pair对象，其元素类型分别是v1和v2的类型。
p1 < p2;                   // 两个pair对象间的小于运算，其定义遵循字典次序：如 p1.first < p2.first 或者 !(p2.first < p1.first) && (p1.second < p2.second) 则返回true。
p1 == p2；                 // 如果两个对象的first和second依次相等，则这两个对象相等；该运算使用元素的==操作符。
p1.first;                  // 返回对象p1中名为first的公有数据成员
p1.second;                 // 返回对象p1中名为second的公有数据成员

5 set是STL中一种标准关联容器。它底层使用平衡的搜索树——红黑树实现，插入删除操作时仅仅需要指针操作节点即可完成，不涉及到内 存移动和拷贝，所以效率比较高。由于他是基于红黑树实现的，所以它天生自带排序功能
插入删除及交换操作 （set中的元素是不会重复的！）

//仿函数
class mycompare {
public:
	 bool operator()(int v1,int v2){
		 return v1 > v2;
	 }
};
void test01() {
	set<int,mycompare>s1;//加了仿函数就是从大到小了
	s1.insert(1);
	s1.insert(4);
	s1.insert(2);
	s1.insert(9);
	s1.insert(5);//不能输入重复的，只有insert功能..set可以自动排序，默认从小到大

	set<int, mycompare>s2;
	s2 = s1;
	s2.swap(s1);

	s2.erase(1);//功能类似于list中的remove


}

查找操作

void test02(){
	set<int>s1;
	s1.insert(1);
	s1.insert(4);
	s1.insert(2);
	s1.insert(9);
	s1.insert(5);

	//find值如果找到是返回迭代器，如果找不到是返回end（）的迭代器
	set<int>::iterator ret = s1.find(9);
	if (ret == s1.end()) {
		cout << "meizhaodao" << endl;

	}
	else
	{
		cout << *ret << endl;//迭代器前面都要加* 迭代器类似于指针
	}

	 ret = s1.lower_bound(3);//找到第一个>=你要查找的数值的值，也是返回迭代器。没找到也会返回end（）
	 ret = s1.upper_bound(2);//找到第一个>你要查找的数值的值，也是返回迭代器没找到也会返回end（）
	pair<set<int>::iterator,set<int>::iterator>ret1 = s1.equal_range(2);//返回lower_bound和upper_bound的值，pair为对组。pari<int,int>
	ret1.first;//第一个迭代器
	ret1.second;//第二个迭代器
}

set容器存入对象的操作

class person {
public:
	person(int age1,int id1) {
		this->age = age1;
		this->id = id1;
  }
public:
	int age;
	int id;
};
class mycompare1 {
public:
	bool operator()(person p1, person p2) {
		return p1.age > p2.age;
	}
};
void test03() {
	set<person,mycompare1>p;
	person p1(10, 20), p2(30, 40), p3(50, 60);
	p.insert(p1);
	p.insert(p2);
	p.insert(p3);

	for (set<person>::iterator it = p.begin(); it != p.end(); it++) {
		cout << (*it).age << " ";
	}
	cout << endl;
}

map 基于红黑树 也具有查找功能而map与multimap差别仅仅在于multiple允许一个键对应多个值。
key不可以重复

//初始化
void test01() {
		//第一个为key第二个为value
	map<int, int>map1;
	//插入数据与set一致只有insert，因为要插入两个值我们可以用pair来插入
   //第一种
	map1.insert(pair<int, int>(10, 10));
	pair<map<int,int>::iterator,bool> ret = map1.insert(pair<int, int>(10, 10));//可以用来判断是否插入
   //第二种
	map1.insert(make_pair(20, 20));
	//第三种
	map1.insert(map<int, int>::value_type(30, 30));
	//第四种
	map1[40] = 40;//如果key不存在则创建key ，如果key存在则改变原来的value值

	for (map<int, int>::iterator it = map1.begin(); it != map1.end(); it++) {
		cout << "key: " << (*it).first << "value " << (*it).second << endl;
	}
}

一些常用的查找方法

//常用查找
void test01() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	//基本的find查找
	vector<int>::iterator ret = find(v1.begin(), v1.end(), 5);
	if (ret == v1.end()) {
		cout << "没有找到" << endl;
	}
	else
		cout << "找到了 :" <<*ret<< endl;
}
class  Person {
public:
	Person(int i, int a) {
		this->age = a;
		this->id = i;
	}
	bool operator ==(const Person& p) const{//要加const我也不懂为啥
		return this->id == p.id && this->age == p.age;
	}
public:
	int id;
	int age;

};

void test02() {
	vector<Person>v;
	Person p1(10, 20), p2(30, 40), p3(50, 60);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);

	vector<Person>::iterator ret = find(v.begin(), v.end(), p1);
	if (ret == v.end()) {
		cout << "没有找到" << endl;
	}
	else
		cout << "找到了 :" << (*ret).id << endl;
}
bool Mysearch(int val) {
	return val > 5;
}
//binary_search 二分查找法 返回bool类型
void test03() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	v1.push_back(9);
	bool ret = binary_search(v1.begin(), v1.end(), 5);
	if (ret == false) {
		cout << "没有找到" << endl;
	}
	else
		cout << "找到了" << endl;

	//查找相邻重复元素
	vector<int>::iterator  it = adjacent_find(v1.begin(), v1.end());
	if (it != v1.end()) {
		cout << "找到了相邻重复元素" << *it << endl;

	}
	else
		cout << "没找到相邻重复元素" << endl;

	//find_if  找符合Mysearch要求的元素，返回第一个满足条件的迭代器，找不到就返回。end()
	find_if(v1.begin(), v1.end(), Mysearch);
	//count count_if
	count(v1.begin(), v1.end(), 9);//统计9出现的次数，返回int个数
		//count_if 与 find_if同理
}