总结笔记3.20

一.万能头文件   include<bits/stdc++.h>

sync_with_stdio(false)  加快程序运行速度

srand(time(0)); rand()%10;  生成随机数

 

二.stack

1.定义:stack<typename>name;
2.stack容器内元素的访问
由于栈（stack）本身是一种后进先出的数据结构，在STL的stack只能通过top（）来访问栈顶元素。
3.操作
（1）push（）
push（x）将x入栈。
（2）top（）
top（）获取栈顶元素。
（3）pop（）
pop用以弹出栈顶元素。
stack<int>st;
for(int i=1;i<=5;i++)
st.push(i);//将1 2 3 4 5依次入栈
for（int i=1,i<=3;i++)
st.pop();//连续三次将栈顶元素出栈，即将5 4 3依次出栈
cout<<st.top()<<endl;
输出结果：2
(4)empty()
empty()可以检测stack内是否为空，返回true为空，返回false为非空。
（5）size（）
size（）返回stack内元素的个数。

三.queue

1.定义:queue<typename>name;
2.queue容器内元素的访问
由于队列（queue）本身就是一种先进先出的限制性数据结构，因此在STL中只能通过front（）来访问队首元素，
或是通过back（）来访问队尾元素。
queue<int>q;
for(int i=1;i<=5;i++)
q.push(i);
printf("%d %d\n",q.front(),q.back() );
输出结果：1 5
3.操作
（1）push（）
push（x）将x进行入队。
（2）front（）、back（）
front（）和back（）可以分别获得队首元素和队尾元素。
（3）pop（）
pop（）令队首元素出队。
queue<int>q;
for(int i=1;i<=5;i++)
q.push(i);
for(int i=1;i<=3;i++）
q.pop()；//出队首元素三次，即依次出队1 2 3.
printf（“%d\n",q.front() );
输出结果：4
(4)empty()
empty检测queue是否为空，返回true则空，返回false则非空。
（5）size（）
size（）返回queue内元素的个数。

四.vector

1.定义：vector <int> vi;

2.操作

添加元素i：vi.push_back（i）;

迭代器：vector<int>::iterator it;

这样就得到了迭代器it，可通过*it来访问vector里的元素。

vector<int>::iterator it=vi.begin();

for(vector<int>::iterator it=vi.begin();it!=vi.end();it++)

添加元素：push_back（）

删除尾元素：pop_back（）

获得vector中元素的个数: size（）

清空vector中的所以元素：clear（）

插入元素：insert（it，x）

// vi.insert（vi.begin（）+2，-1），将-1插入到vi[2]的位置。

删除单个元素：erase（）

//vi.erase（vi.begin（）+3）

删除一个区间内的所以元素：erase（first，last）

//vi.erase(vi.begin()+1，vi.begin()+4).

五.sort

1.定义

sort是用来排序的函数，它根据具体情形使用不同的排序方法。sort函数的使用必须加上头文件#include<algorithm>,

2.使用方法即操作

sort(首元素地址（必填），尾元素地址的下一个地址（必填），比较函数（非必填））；

可以看到，sort的参数有三个，其中前两个是必填的，而比较函数则可以根据需要填写，

如果不写比较函数，则默认对前面给出的区间进行递增排序。

int a[6]={9,4,2,5,6,-1}

sort(a,a+6);//将a[0]~a[5]从小到大排序

for(int i=0;i<6;i++)

cout<<a[i]<<" ";

输出结果：-1 2 4 5 6 9

对char型数组排序（默认为字典序）：

char c[]={'T','W','A','K'};

sort(c,c+4);

for(int i=0;i<4;i++)

cout<<c[i];

输出结果：AKTW

sort的第三个可选参数就是compare函数（一般写作cmp函数）。

如果想要从大到小来排序，则要使用比较函数cmp来“告诉”sort何时要交换元素，可以这样写：

bool cmp(int a,int b)

return a>b;//可以理解为当a>b时把a放在b前面

int a[]={3,1,4,2};

sort(a,a+4,cmp);

for(int i=0;i<4;i++)

cout<<a[i]<<" ";

输出结果:4 3 2 1

对char型数组从大到小排序：

bool cmp(char a,char b)

return a>b;

int main()

{char c[]={'T','W','A','K'};

sort(c,c+4,cmp);

for(int i=0;i<4;i++)

cout<<c[i];

}

输出结果：WTKA

记忆方法：如果要把数据从小到大排序，那么就用"<",因为”a<b“就是左小右大；如果要把数据从大到小排序，

那么就用”>“。

（2）结构体数组的排序

现定义了如下的结构体：

struct node{int x,y;

}ssd[10];

如果想让ssd数组按照从小到大排序（即进行一级排序），那么可以这样写cmp函数：

bool cmp(node a,node b)

return a.x>b.x;//按x值从大到小对结构体数组排序

ssd[0].x=2;

ssd[0].y=2;

ssd[1].x=1;

ssd[1].y=3;

ssd[2].x=3;

ssd[2].y=1;

sort(ssd,ssd+3,cmp);//排序

for(int i=0;i<3;i++)

cout<<ssd[i].x<<" "<<ssd[i].y<<endl;

输出结果：3 1

                 2 2

                 1 3

而如果想先按x从大到小排序，但当x相等的情况下，按照y的大小从小到大来排序（即进行二级排序），那么cmp的写法是：

bool cmp(node a,node b)

if(a.x!=b.x) return a.x>b.x;

else return a.y<b.y;

这里的cmp函数首先判断结构体内的x元素是否相等，如果不相等，则直接按照x的大小来排序；否则，比较两个结构体中y

的大小，并按y从小到大排序。

（3）容器的排序

在STL标准容器中，只有vector、string、deque是可以使用sort的。这是因为像set、map这种容器是用红黑树实现的，元素

本身有序，故不允许使用sort排序。

六.priority_queue

1.定义
要使用优先队列，应先添加头文件#include<queue>.
priority_queue<typename>name;
2.priority_queue容器内元素的访问
优先队列没有front（）函数，back（）函数，只能通过top（）函数来访问队首元素（也可以称为堆顶元素），
也就是优先级最高的元素。
3.操作
（1）push（）
push（x）将令x入队。
（2）top（）
top()可以获得队首元素。
（3）pop（）
pop（）令队首元素出列。
（4）empty（）检测优先队列是否为空，返回true则空，返回false则非空。
（5）size（）
size()返回优先队列内元素的个数。
4.priority_queue内元素优先级的设置
（1）基本数据类型的优先级设置
下列两种优先队列的定义是等价的（注意最后两个>之间有一个空格）
priority_queue<int>q;
priority_queue<int,vector<int>,greater<int>>q;
可以发现，第二种定义方式的尖括号内多出了两个参数:一个是vector<int>,另一个是less<int>.其中
vector<int>填写的是来承载底层数据结构堆（heap）的容器，如果第一个参数是double型或char型，
则此处只需要填写vector<double>或vector<char>；而第三个参数less<int>则是对第一个参数的比较类，
less<int>表示数字大的优先级越大，而greater<int>表示数字小的优先级越大。
如果想让优先队列总把最小的元素放在队首，只需进行如下定义：
priority_queue<int,vector<int>,greater<int>>q;

七.string

1.定义。
定义string的方式跟基本数据类型相同，只需要在string后跟上变量名即可：
string str；
如果要初始化，可以直接给string类型的变量进行赋值：
string str="abcd";
2.string中内容的访问。
（1）通过下标访问
一般来说，可以直接像字符数组那样去访问string。
（2）通过迭代器访问。
定义：string ：：iterator it。
string str="abcd";
for(string : :iterator it=str.begin();it!=str.end();it++)
printf("%c",*it)
3.string常见操作
（1）operator+=
这是string的加法，可以将两个string直接拼接起来。
string str1="abc",str2="xyz";
str1+=str2;//将str2直接拼接到str1上。
cout<<str1<<endl;
输出结果：abcxyz
 (2)compare operator
两个string类型可以直接使用=，！=，<,>=比较大小，比较规则是字典序。
（3）length()/size()
length()返回string的长度，size（）与length（）基本相同。
（4）insert（）
第一种：insert（pos，string）在pos号位置插入字符串string。
string str="abcxyz",str2="opq";
str.insert(3,str2);//往str[3]处插入opq，这里str2的位置直接写"opq"也是可以的。
输出结果：abcopqxyz
第二种：insert(it,it2,it3) it为原字符串的欲插入位置，it2和it3为待插入字符串的首尾迭代器，
用来表示串[it2,it3]将被插在it的位置上。
string str="abcxyz",str2="opq";
str.insert(str.begin()+3,str2.begin(),str2.end() );
输出结果：abcopqxyz
（5）erase（）
erase()有两种用法：删除单个元素、删除一个区间内的所有元素。
删除单个元素：
str.erase(it)用于删除单个元素，it为需要删除的元素的迭代器。
string str="abcdefg";
str.erase(str.begin()+4);//删除4号位（即e）。
输出结果：abcdfg
删除一个区间内的所有元素：
str.erase（first，last）:
first为需要删除的区间的起始迭代器，last为需要删除的区间的末尾迭代器的下一个地址，即删除[first,last).
string str="abcdefg";
str.erase(str.begin()+2,str.end()-1);
输出结果：abg.
str.erase(pos,length):
其中pos为需要开始删除的起始位置，length为删除的字符个数。
string str="abcdefg";
str.erase(3,2);//删除从3号位开始的2个字符，即de。
输出结果：abcfg.
(6) clear()
clear()用以清空string中的数据。
（7）substr（）
substr（pos，len）返回从pos号开始，长度为len的子串。
string str="Thank you for your smile.";
cout<<str.substr(0,5)<<endl;
cout<<str.substr(14,4)<<endl;
cout<<str.substr(19,5)<<endl;
输出结果：Thank
                 your
                 smile
（8） string::npos
string::npos是一个常数，其本身的值为-1，但由于是unsigned_int类型，因此实际上也可以认为是unsigned_int类型的最大值。
string：：npos用以作为find函数失配时的返回值。可认为string：：npos等于-1或4294967295.
（9）find()
str.find(str2），当str2是str的子串时，返回其在str中第一次出现的位置；如果str2不是str的子串，那么返回string：：npos。
str.find(str2,pos) 从str的pos号位开始匹配str2，返回值与上相同。
string str ="Thank you for your smile";
string str2="you";
if(str.find(str2)！=string ::npos)
cout<<str.find(str2)