STL 笔记整理【学习记录】

本文链接：https://blog.csdn.net/m0_51990674/article/details/110456078

STL 笔记整理【学习记录】

STL ACM方面整理，个人笔记，若有不足，请谅解。

函数：

sort（***）:

sort [ start , end , cmp )

函数用于C++中，对给定区间所有元素进行排序，默认为升序，也可进行降序排序。sort函数进行
排序的时间复杂度为n*log2n，比冒泡之类的排序算法效率要高的多。
默认从小到大排sort .
stl内置了几个cmp，一个是greater< int >( )，一个less< int >( );

less变成升序（从左到右遍历下标时，数组元素是从小到大）
greater变成降序（从左到右遍历下标时，数组元素是从大到小）

sort(a,a+n,less<int>());
sort(a,a+n,greater<int>());

也可以自己写出来降序cmp

/*
	降序的cmp 简单写法
*/
bool up(int a,int b){
	return a>b;
}

当然也可以对结构体排序

/*
	例子：先按照体重从小到大，在按照身高从高到低。
*/
#include<iostream>
#include<algorithm>
using namespace std;
/*
	180  67
	184	 75
	176  34
	189  68 
	164  30
	189  67
*/
struct node{
	int weight;
	int high;
}a[50];
bool up_struct(node a,node b){
	if(a.weight==b.weight){
		return a.high > b.high ;
	}else{
		return a.weight < b.weight ;
	}
}
int main(){
	for(int i=0;i<=5;i++){
		cin>>a[i].high>>a[i].weight;
	}
	sort(a,a+6,up_struct);
	for(int i=0;i<=5;i++){
		cout<<a[i].high<<" "<<a[i].weight<<endl;
	}
	//up_struct是自定义的排序规则。
	return 0;
}

lower_bound()函数 (***)：

注意：使用lower_bound()必须提前排序。
在 [first, last) 区域内查找不小于(>=) val 的元素
在 [first, last) 区域内查找第一个不符合 cmp 规则的元素

函数思想是二分，时间复杂度为O log(N)，如果能找到返回一个正向迭代器，指向该元素，如果找不到，指向last。（由于我比较菜，理解为指针。

#include <iostream>	// std::cout
#include <algorithm>	// std::lower_bound
#include <vector>	// std::vector
using namespace std;
//以普通函数的方式定义查找规则
bool mycomp(int i,int j)
{
    return i>j;
}
//以函数对象的形式定义查找规则
class mycomp2
{
public:
    bool operator()(int i,  int j)
    {
        return i>j;
    }
};

int main()
{
    int a[5] = { 1,2,3,4,5 };
    //从 a 数组中找到第一个>=3 的元素,必须为非降的
    int *p = lower_bound(a, a + 5, 3);
    cout << "*p = " << *p << endl;
    cout << "下标是：" << p-a << endl;
    vector<int> myvector{5,8,6,4,3,0,1,2};
    //根据 mycomp2 规则，从 myvector 容器中找到第一个〈＝3，容器为降序
    vector<int>::iterator iter = lower_bound(myvector.begin(), myvector.end(),3,mycomp2());
    cout << "*iter = " << *iter;
    cout << "下标是：" << iter-myvector.begin() << endl;
    return 0;
}

upper_bound()函数 (***）：

与lower_bound()同理，可以理解为；upper_bound()是>,而lower_bound是>=

next_permutation (***)：

void next_permutation(begin, end)
void next_permutation(begin, end, comp)

这个函数就是输出字典序的下一个排序方式，如果没有，返回（好像是-1,也或者是flase，记不清）一般配合do while来写。
样例如下：

/*
	例如 1 2 3 4 5
排序后是 1 2 3 5 4
*/ 
#include <iostream> 
#include <algorithm>
using namespace std;
int main() {
	int a[3]={1,2,3};
do{
	for(int i=0;i<3;i++) {
		cout<<a[i]<<' ';
	}
	cout <<'\n';
}while(next_permutation(a,a+3));
	return 0;
}

ps:一点自己的理解，没有考证，我目前理解：next_permutation函数会把所排序数组按照字典序排出下一个。

prev_permutation函数 (***)：

和 next_permutation 函数一样，只是上一字典序。

unique函数 (***)：

注意：
使用该函数前，一定要先对序列进行排序，因为这里的去除并非真正意义的erase，而是将不重复的元素放到容器的前面，返回值是去重之后的尾地址。
参数：
void unique(begin, end)
返回去重后最后一个元素的下一个位置的迭代器

理解：去重不是把重复的去掉，而是把重复的扔后面，返回的是尾地址。

容器：

队列，栈，都可以用数组模拟，且效率更高。

string 字符串

内部常用函数:

size()/length() 返回字符串长度
empty() 是否为空
clear() 清空
substr() 起始下标，(子串长度)) 返回子串
c_str() 返回字符串所在字符数组的起始地址

queue 队列：

先进先出，类似于排队（不能插队

常用内部函数：

size():判断大小
empty():判断是否为空
push():放入一个元素
front() :返回队头元素
back():返回队尾元素
pop():弹出队头元素

/*
	简单测试几个函数；
*/
#include<iostream>
#include<queue>
using namespace std;
int main(){
	queue<int> demo;
	if(demo.empty())cout<<"这时候demo是空的"<<endl; 
	demo.push(1);
	demo.push(2);
	demo.push(3);
	demo.pop();
	if(demo.empty())cout<<"这时候demo是有两个元素的"<<endl;
	int d1=demo.front(); 
	int d2=demo.back();
	cout<<"d1="<<d1<<endl<<"d2="<<d2;
	return 0;
}

priority_queue, 优先队列，默认是大根堆：

大根堆：放进去的时候就已经从大到小排序了，并且大的在前。

当然也可以定义成小根堆：

priority_queue<int,vector<int>,less<int> > pq
也可以将元素取负

priority_queue（）常用函数：

push() 插入一个元素
top() 返回堆顶元素（可不是front）
pop() 弹出堆顶元素

~~一般操作和queue几乎相同~~ ，下面重点记录一下对结构体的读入和排序。

/*
	进一步加深了对结构体的理解，原来node与int,double这种类似，是自己写出来的结构。
*/
#include<iostream>
 using namespace std;
 struct node{
 	int weight;
 	int high;
 }a[10];
 int main(){
 	priority_queue<node> pq;
 	//放入要加{}
 	pq.push({1,2});
 	return 0;
 }

上面代码会报错。

/*
struct less : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
    };
 */
 /*
 这就是原因，我也不太懂。但是很容易理解因为他优先队列会对结构体排序，他不知道咋排，所以会编译都过不了。
 */

But，想要做到还是可以完成的。

/*
	按照weight从小到大排序，如果weight一样，按照身高高排序
*/
#include<iostream>
#include<queue>
using namespace std;
struct node{
 	int weight;
 	int high;
 	bool operator <(const node & o)const
 	{
 		if(weight==o.weight)return high<o.high;
 		return weight>o.weight;
	}
 }a;
 int main(){
 	priority_queue<node> pq;
 	pq.push({2,2});
 	pq.push({3,1});
 	pq.push({1,3});
 	cout<<pq.top().high;
 	return 0;
 }

stack, 栈：

特点：后入后出

内部常用函数：

size()
empty()
push() 向栈顶插入一个元素
top() 返回栈顶元素
pop() 弹出栈顶元素

deque,双端队列：

特别注意：支持数组运算

内部函数：

size()
empty()
clear()
front()/back()
push_back()/pop_back()
push_front()/pop_front()
begin()/end()
[] 支持数组运算

map

理解为map<标签，其他类型>

类似于数组的下角标，map<int，int> 第一个int做到的就是和数组 a[ ]中括号里面作用类似：
map不止支持int int ，很多其他类型也支持，以后做补充。

map<int,int> a;
a[第一个int]=第二个int；

unordered_map

map是有序的，但是unordered_map是无序的，内置哈希，效率很高。

vector

特征：就是个无限增长的数组

内部常用函数:

size() 返回元素个数
empty() 返回是否为空
clear() 清空
front()/back()
push_back()/pop_back()
begin()/end()
[ ]支持数组形式直接访问

总结：对STL了解还不是很深，会根据认识的不同程度修改，仅供自己参考。不常用STL今天没有总结进去，以后有精力会加入，但是对于ACM确实用到的不多。

STL 笔记整理【学习记录】