STL的认知

STL

vector 头文件<vector>

初始化,定义,定义长度，定义长度并且赋值，从数组中获取数据
返回元素个数size()
判断是否为空empty()
返回第一个元素front()
返回最后一个数back()
删除最后一个数pop_back()
插入push_back(x)
清空clear()
begin()
end()
使用size()遍历
使用begin()和end()遍历
使用auto遍历

pair 头文件<utility>

初始化，pair<int,int>，make_pair(1,1)
第一个元素first,第二个元素second
嵌套
排序

queue 头文件<queue>

初始化
长度size()
是否为空empty()
队尾插入push()
删除队头pop()
返回对头front()
返回队尾back()
清空，初始化

stack 头文件<stack>

初始化
长度size()
栈顶插入一个元素push()
返回栈顶元素top()
弹出栈顶元素pop()

string 头文件<string>

初始化
截取substr(1,5)
大小和长度 size() length()
头指针 c_str()
拼接 +
尾插 push_back()
插入 insert()

priority_queue 头文件<queue>

初始化,默认大根堆
长度size()
是否为空empty()
队尾插入push()
删除队头pop()
返回堆顶top()
清空，初始化

deque 头文件<deque>

初始化
长度size()
是否为空empty()
返回第一个元素front()
返回最后一个数back()
删除最后一个数pop_back()
插入push_back(x)
队首插入一个元素push_front()
begin()
end()

set 头文件<set>

初始化
返回元素个数size()
是否为空empty()
清空clear()
第几个数begin()
最后一个的后一个end()
插入insert()
查找find()
删除erase(x)
返回大于等于x的最小的的迭代器lower_bound(x)
返回大于x的最小的数的迭代器upper_bound(x)

map 头文件<map>

初始化
插入insert()
删除erase()
查找find()
个数count()
返回大于等于x的最小的的迭代器lower_bound(x)
返回大于x的最小的数的迭代器upper_bound(x)

unordered

unordered_set
unordered_map
unordered_muliset
unordered_multimap

algorithm 头文件<algorithm>

排序sort()
最值max、min
最大公约数__gcd
交换swap(a,b)
二分查找lower_bound()、upper_bound()
倒置reverse()
全排列next_permutation()

示例代码

vector

#include<iostream>
#include<vector>
using namespace std;
int main () {
	//初始化一个vector,长度为10，值都为1
	vector<int> v0(10,1);
	//初始化v1,它的值从arr中拿，初始化v2,它的值从v1拿，使用三种遍历遍历出v2 
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    vector<int> v1(arr,arr+10);
    vector<int> v2(v1.begin(),v1.end());
	    //第一种
		for(int i=0;i<v2.size();i++) cout<<v2[i]<<" ";
		cout<<endl;
		//第二种
		for(auto i=v2.begin();i!=v2.end();i++) cout<<*i<<" ";
		cout<<endl;
		//第三种 
	    for(auto x:v2) cout<<x<<" ";
	    cout<<endl;
	//返回元素个数size()
	cout<<v2.size()<<endl;
	//判断是否为空empty()
	cout<<v2.empty()<<endl;
	//返回第一个元素front()
	cout<<v2.front()<<endl;
	//返回最后一个数back()
	cout<<v2.back()<<endl;
	//删除最后一个数pop_back()
	v2.pop_back();
	//插入push_back(x)
	v2.push_back(15);
	//清空clear() 
	v2.clear();
    return 0;
}

pair

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
using namespace std;

//根据first的值升序排序
bool cmp1(pair<int,int> a,pair<int,int> b) {
	return a.first < b.first;
}
//根据second的值升序排序
bool cmp2(pair<int, int> a, pair<int, int> b)
{
    return a.second < b.second;
}

int main () {
	//初始化，pair<int,int>，make_pair(1,1)
	pair<int,int> p(1,1);
	pair<int,int> q = make_pair(1,1);
	//第一个元素first,第二个元素second
	cout<<p.first<<endl;
	cout<<p.second<<endl;
	//嵌套
	pair<int,pair<int,int>> k(2,{1,1});
	//排序
	vector<pair<int, int>>vec;
    vec.push_back({ 1,2 });
    vec.push_back({ 4,2 });
    vec.push_back({ 3,3 });
    vec.push_back({ 2,1 });
    sort(vec.begin(), vec.end(), cmp1);
    cout << "根据first的值升序排序:" << endl;
    for (auto it = vec.begin();it != vec.end();it++)
    {
        cout << "(" << it->first << "," << it->second << ")" << endl;
    }
   	sort(vec.begin(),vec.end(),cmp2);
   	cout << "根据second的值升序排序:" << endl;
   	for (auto it = vec.begin();it != vec.end();it++)
    {
        cout << "(" << it->first << "," << it->second << ")" << endl;
    }
    return 0;
}

queue

#include<iostream>
#include<queue>
using namespace std;

int main () {
	//初始化
	queue<int> q;
	//队尾插入push()
	q.push(1);
	q.push(2);
	q.push(3);
	//长度size()
	cout<<q.size()<<endl;
	//是否为空empty()
	cout<<q.empty()<<endl;
	//删除队头pop()
	q.pop();
	//返回对头front()
	cout<<q.front()<<endl;
	//返回队尾back()
	cout<<q.back()<<endl;
	//清空，初始化
	q = queue<int>();
    return 0;
}

#include<iostream>
#include<stack>
using namespace std;

int main () {
	//初始化
	stack<int> s;
	//栈顶插入一个元素push()
	s.push(1);
	s.push(2);
	s.push(3);
	//长度size()
	cout<<s.size()<<endl;
	//返回栈顶元素top()
	cout<<s.top()<<endl;
	//弹出栈顶元素pop()
	s.pop();
	cout<<s.top();
    return 0;
}

string

#include<iostream>
#include<string>
using namespace std;

int main () {
	//初始化
	string s = "abcdefg";
	//截取
	string st = s.substr(1,5);
	cout<<st;
	//大小和长度 
	cout<<s.size()<<endl;
	cout<<s.length()<<endl;
	//头指针
	printf("%s",s.c_str()); 
	//拼接
	st = st + "111";
	cout<<st<<endl;
	//尾插
	s.push_back('h');
	cout<<s<<endl; 
	//插入
	s.insert(0,st,0,2);
	cout<<s<<endl; 
    return 0;
}

priority_queue

#include<iostream>
#include<queue>
using namespace std;

int main () {
	//初始化,默认大根堆
	priority_queue<int> pq;
	//队尾插入push()
	pq.push(1);
	pq.push(2);
	pq.push(3);
	//长度size()
	cout<<pq.size()<<endl;
	//是否为空empty()
	cout<<pq.empty()<<endl;
	//返回堆顶top()
	cout<<pq.top()<<endl;
	//删除队头pop()
	pq.pop();
	cout<<pq.top();
	//清空，初始化
	pq = priority_queue<int>();
    return 0;
}

deque

#include<iostream>
#include<deque>
using namespace std;

int main () {
	//初始化
	deque<int> d;
	//队尾插入push_back(x)
	d.push_back(1);
	d.push_back(2);
	d.push_back(3);
	//长度size()
	cout<<d.size()<<endl;
	//是否为空empty()
	cout<<d.empty()<<endl;
	//返回第一个元素front()
	cout<<d.front()<<endl;
	//返回最后一个数back();
	cout<<d.back();
	//队首插入一个元素push_front()
	d.push_front(5);
	//删除最后一个数pop_back()
	d.pop_back();
    return 0;
}

set

#include<iostream>
#include<set>
using namespace std;

int main () {
	//初始化
	set<int> s;
	//插入insert()
	s.insert(1);
	s.insert(2);
	s.insert(3);
	s.insert(4);
	s.insert(5);
	s.insert(6);
	//返回元素个数size()
	cout<<s.size()<<endl;
	//是否为空empty()
	cout<<s.empty()<<endl;
	//查找find()
	set<int>::iterator it = s.find(3);
	if(it==s.end()) cout<<false<<endl;
	else cout<<true<<endl;
	//删除erase(x)
	s.erase(2);
	//返回大于等于x的最小的的迭代器lower_bound(x)
	cout<<*s.lower_bound(3)<<endl;
	//返回大于x的最小的数的迭代器upper_bound(x)
	cout<<*s.upper_bound(3)<<endl;
	//清空clear()
	s.clear();
    return 0;
}

map

#include<iostream>
#include<map>
using namespace std;

int main () {
	//初始化
	map<int,int> m;
	//插入insert()
	//m[1] = 1;
	m.insert(make_pair(1,1));
	m.insert(make_pair(2,2));
	m.insert(make_pair(3,3));
	m.insert(make_pair(4,4));
	m.insert(make_pair(5,5));
	//删除erase()
	map<int,int>::iterator it = m.find(5);
	m.erase(it);
	//查找find()
	it = m.find(5);
	if(it==m.end()) cout<<false<<endl;
	else cout<<true<<endl;
	//返回大于等于x的最小的的迭代器lower_bound(x)
	it = m.lower_bound(3);
	cout<<it->second<<endl;
	//返回大于x的最小的数的迭代器upper_bound(x)
	it = m.upper_bound(3);
	cout<<it->second<<endl;
    return 0;
}

unordered_set

#include<iostream>
#include<unordered_set>
using namespace std;

int main () {
	//初始化
	unordered_set<int> us;
	//插入insert()
	us.insert(1);
	us.insert(2);
	us.insert(3);
	//删除erase()
	us.erase(3); 
	//查找find()
	unordered_set<int>::iterator it;
	it = us.find(3);
	if(it==us.end()) cout<<false<<endl;
	else cout<<true<<endl;
	//插入insert()
	us.insert(3);
	it = us.find(3);
	if(it==us.end()) cout<<false<<endl;
	else cout<<true<<endl;
    return 0;
}

algorithm

#include<iostream>
#include<algorithm>
using namespace std;

bool cmp(int a,int b) {
	return a>b;
}

int main () {
	//排序 
	int arr[] = {1,3,2,5,4,9,7};
	int length = sizeof(arr)/sizeof(int);
	sort(arr,arr+length,cmp);
	for(int i=0;i<length;i++) {
		cout<<arr[i]<<" ";
	}
	cout<<endl;
	//最值
	cout<<max(1,3)<<endl; 
	//最大公约数
	cout<<__gcd(20,30)<<endl;
	//交换
	int a = 1;
	int b = 2;
	swap(a,b);
	cout<<a<<endl;
	//二分查找 
	int ar[] = {0, 1, 3, 5, 8, 10, 16};
    cout<<*lower_bound(ar, ar + 7, 3)<<endl;
    cout<<lower_bound(ar, ar + 7, 3)-ar<<endl;
    //倒置
	reverse(arr, arr + sizeof(arr) / sizeof(int)); 
	for(int i=0;i<length;i++) {
		cout<<arr[i]<<" ";
	}
	cout<<endl;
	//全排列
	int c[] = {1, 2, 3};
	do{
		cout << c[0] << " " << c[1] << " " << c[2] << endl;
	} while (next_permutation(c, c+3)); 
    return 0;
}