【STL部分知识点总结】（vector,queue,priority_queue,stack）

一、Vector

译为“向量”，也叫“变长数组”，即根据需要改变数组长度。使用时应加头文件，即

#include <vector>

1.定义：

一维数组：vector <typename> name;

typename可以为任何基本类型，如int ,double,结构体等，也可以是STL标准容器，如vector,set等

二维数组：vector <vector<typename> >-name;//> >之间要加空格；

vector <typename>name[100];//100为自己设定的长度；

二者区别：第一种定义数组的两个维都可以变长，而第二种有一位长度固定为100（自设）；

2.访问方式

（1）通过下标访问，下标范围从0到vi.size()-1

        eg: vi[10];

(2)通过迭代器（类似指针）访问；

        定义：vector<typename>::iterator it;

        vi[i] 与*(vi.begin()+i)等价

#include <stdio.h>
#include <vector>
using namespace std;

int main()
{
vector<int> vi;
for(int i=1;i<=5;i++)
{vi.push_back(i);}        //push_back用法见下
vector<interesting>::iterator it=vi.begin();   //it指向vi的首地址；
for(int i=0;i<5;i++)
{printf("%d ",*(it+i));}      //输出vi[i];
return 0;
}

//输出结果1 2 3 4 5

 另一种访问方式：迭代器自增自减；

for(vector<int>::iterator it=vi.begin();it!=vi.end();it++)
{printf("%d",*it);}

（拓）1~  begin()函数取vi的首地址元素；

                 end()函数取vi尾元素的下一个地址，作为迭代器末尾标志，不存放任何元素。

                美国人习惯左开右闭，此处便是如此。

            2~ 在常用的STL容器中，只有vector和string中才允许使用如vi.begin()+3这种迭代器加                    上数字的写法

3.常用函数：

（1）push_back()

        push_back(x)在vector后面加元素x,时间复杂度为O(1);

vector<int> vi;
for(int i=1;i<5;i++)
{vi.push_back(i);}//将1，2，3，4依次插入vi末尾

（2）pop_back()

        删除末尾元素，时间复杂度为O（1）；

vector<int> vi;
for(int i=1;i<5;i++)
{vi.push_back(i);}//将1，2，3，4依次插入vi末尾
vi.pop_back();//删除末尾的3；

（3）size()

        获取元素个数，时间复杂度为O（1）,返回类型为unsigned;

      eg:   vi.size();

（4）clear()

        清空vector内的所有元素，时间复杂度O（N）,N为元素个数；

        eg： vi.clear();

  (5)insert()

        insert(it,x),向vector中it位置的元素插入x,原该位置及以后的元素向后移；

        eg：vi.insert(vi.begin()+2,-2);//向vi[2]处插入-2；

（6）erase（）

        删除单个元素，或者删除一个区间内的所有元素；

        eg: vi.erase(vi.begin()+3);//删除vi[3];

              vi.erase(vi.begin(),vi.begin()+4);//删除[vi[0],vi[4])!!!!

  (7)empty()

         判断vector内是否为空，即有没有元素，返回bool类型；

        eg: vi.empty();

二、queue

队列，先进先出的限制性数据结构，头文件#include<queue>

1.定义：

        queue<typename> name;

2.访问方式：

因为是先进先出的限制性数据结构，只能通过front()访问队首元素，back()访问队尾元素，使用前必须用empty()先判断队列是否为空，否则会因为队空而出错；

#include <stdio.h>
#include <queue>
using namespace std;
int main()
{queue<int> s;
 for(int i=1;i<=5;i++)
{s.push(i);}//1，2，3，4，5依次入队
printf("%d %d",s.front(),s,back());//输出1 5；
}

 3.常用函数

（1）push()

        入队，时间复杂度为O(1);

         s.push(x);

  (2)front(),back()

        分别获得队首和队尾元素；时间复杂度为O(1);

        s.front();            s.back();

（3）pop()

        令队首元素出队；时间复杂度为O(1); 

         s.pop();

(4)empty()

        判断是否为空；返回bool型；

(5)size()

        求queue内元素个数；

        s.size();

三、priority_queue

优先队列，底层由堆来实现，队首元素为优先级最高的那一个；一般数字越大，优先级越高，如果是char型，即字典序最大的；

1.基本数据类型的优先级设置：

priority_queue<int> q;

priority_queue<int,vector<int>,less<int>>q;

第二种写法的第二种参数vector<int>填写的是用来承载底层数据结构堆的容器（不是很理解）

第三个参数less<int>是对第一个参数的比较类，表示数字大的优先级优先，greater<int>表示数字小的优先级优先；

#include<stdio.h>
#include<queue>
using namespace std;
int main()
{priority_queue<int,vector<int>,greater<int> > q;//从小到大排序；
q.push(3);
q.push(4);
q.push(1);
printf("%d\n",q.top());
return 0;
}
//输出 1；

2.结构体的优先级设置：

【优先队列的这个函数与sort中的cmp函数效果相反!!!】

(1)by重载函数(对已有的运算符进行重新定义)，写法如下：

struct fruit
{
 string name;
 double price;
 friend bool operator < (fruit f1,fruit f2){
 return f1.price<f2.price;}
};

(拓)friend 为友元；bool operator < (fruit f1,fruit f2）对"<"进行重载，重载大于号会编译错误，f1>f2等价于f2<f1,f1==f2等价于判断 !(f1<f2）&&!(f2<f1);

即可定义fruit类型的优先队列，内部以价格高的水果为优先级高，

（如果想以价格低的水果为优先级高，只需要将最后一句改为return f1.price>f2.price）

#include <iostream>
#include <string>
#include <queue>
using namespace std;
struct fruit
{
 string name;
 double price;
 friend bool operator <(fruit f1,fruit f2)
 {return f1.price<f2.price;}  //实际为从大到小排序；
}f1,f2,f3;
int main()
{
 priority_queue<fruit> q;
 f1.name="peach";
f1.price=3;
f2.name="apple";
f2.price=2;
f3.name="banana";
f3.price=1;
q.push(f1);
q.push(f2);
q.push(f3);
cout<<q.top().name<<" "<<q.top().price;
return 0;
}

}

（2）by第二种定义方式，用cmp代替greater<>;

#include <iostream>
#include <string>
#include <queue>
using namespace std;
struct fruit
{
 string name;
 double price;
}f1,f2,f3;
struct cmp{
bool operator ()(fruit f1,fruit f2)//将<改为()，并且定义在结构体外；
 {return f1.price<f2.price;}
};
int main()
{
 priority_queue<fruit,vector<fruit>,cmp> q;
 f1.name="peach";
f1.price=3;
f2.name="apple";
f2.price=2;
f3.name="banana";
f3.price=1;
q.push(f1);
q.push(f2);
q.push(f3);
cout<<q.top().name<<" "<<q.top().price;
return 0;
}

（拓）结构体内数据较大时（出现字符串或者数组） ，可以使用引用提高效率；此时比较类的参数中需要加上“const”和“&”；如下：

friend bool operator <(const fruit &f1,const fruit &f2)
{return f1.price<f2.price;
}

bool operator ()(const fruit &f1,const fruit &f2)
{return f1.price<f2.price;}

3.常见用途

可以解决些贪心问题，优先队列的本质是堆；

注意：top（）之前必须先用empty()判断队列是否为空；

四.stack

实现后进先出的容器，头文件#include <stack>;

1.定义;

stack<typename>name;

2.访问

‘只能通过top()访问栈顶元素；

3.常用函数示例：

stack.push（m）;m入栈；

stack.pop    (m)   ; 弹出栈顶元素m;

stack.top();获得栈顶元素：

stack.size();求长度；

stack.empty();判断是否为空；

4.常见用途：

用来模拟实现一些递归，防止程序对栈内存的限制而导致程序运行出错。一般栈的内存空间比较小。

码字不易！感谢观看！