STL介绍与习题

内容参考书籍《算法笔记》

1.vector

  在一些用普通数组可能会超内存的情况下，可以选择用vector来存储数据，vector可以理解为“长度可以根据需要改变的数组”。并且用vector比较节省空间。

  使用vector，需要添加头文件#include<vector> , 而且还得在头文件下面加上using namespace std;

  （1）. vector的定义

　　vector<typename> name; 　　//单独定义一个vector ，相当于一维数组name[SIZE].  typename表示数据类型

　　vector<vector<int> > 　　　　//如果typename也是一个STL容器，定义的时候记得在>>符号之间加上空格，因为c++11之前标准的编译器会把它视为移位操作。

　　vector<typename> v[SIZE];   //vector数组的定义，v[0]~v[SIZE - 1]中每一个都是一个vector容器

  （2）.元素的访问

　　一般有两种访问方式 ：通过下标访问或者通过迭代器访问。

　　通过下标访问 ： 和普通数组一样。

　　通过迭代器访问 ： 迭代器(iterator)可以理解为一种类似指针的东西。其定义是：vector<typename>::iterator it;

　　   这样it就是迭代器，并且可以用*it来访问vector里的元素

　　　如：

　　　　for(int i = 0 ; i < 5 ;i ++ )　　printf("%d", *(it + i));

　 (3).vector 的常用函数分析

　　push_back()  //在vector后面添加一个元素,如push_back(x);   时间复杂度是O(1)。

　　pop_back()   //删除vector的尾元素。 时间复杂度是O(1)。

　　size()   　　  //获取vector中元素个数，时间复杂度O(1)。

　　clear()　　　//清空vector中的所有元素，时间复杂度是O(N)，N是vector中元素的个数。

　　 　　如：

　　　　#include<iostream>

　　　　using namespace std;

　　　　int main(){

　　　　vector<int>v;

　　　　for(int i = 1 ; i <= 3 ; i++) vi.push_back(i);

　　　　vi.clear();

　　　　cout << vi.size();

　　　　return 0;

　　　　}

  　　　　输出结果：0

　　insert()  //  insert(it , x) 用来向vector的任意迭代器it处插入一个元素x，时间复杂度O(N)。

　　erase()  //有两种用法：删除单个元素、删除一个区间内的所有元素。时间复杂度都为O(N)。

　　　　erase  (it)  　　　 //  删除迭代器为it处的元素。

　　　　erase  (first , last) // 删除[first , last)内的所有元素

　　(4).vector常见用途

　　　　1.作为数组

　　　　2.用邻接表存储图

例题：http://acm.hdu.edu.cn/showproblem.php?pid=4841

AC代码：

#include<iostream>

#include<vector>

using namespace std;

int n , m ;

vector<int>v;

const int N = 1e6 + 10;

int res[N];

int main(){

    while(cin >> n >> m){


        memset(res,1,sizeof(res));
        v.clear();
        for(int i = 0 ; i < 2*n ; i++)
            v.push_back(i);

        for(int i = 0 ,pos = 0 , num = 2 * n ; i< n ;i++){

            pos = (pos + m - 1) % num ;

            num --;

            res[v[pos]] = 0;

            v.erase(v.begin() + pos);
        }

        for(int i = 0 ; i< 2 * n;i++){

            if((i%50 == 0) && (i != 0)) printf(" ");

            if(res[i]) printf("G");

            else printf("B");

        }
       printf(" ");
    }
    return 0;
}

2.stack

　　后进先出。#include<stack>并且用using namespace std;

（1）在STL中栈只能通过top()来访问栈顶元素

（2）常用函数

　　push(x) //将x入栈，时间复杂度O(1)

　　top()  //获得栈顶元素，时间复杂度O(1)

　　pop() //弹出栈顶元素，时间复杂度O(1)

　　empty() //检测栈是否为空，返回true为空，返回false为非空，时间复杂度O(1)

　　size() //返回栈中元素个数，时间复杂度O(1)

（3）常见用途

　　可以用栈来模拟实现一些递归算法，应用于DFS

例题：http://acm.hdu.edu.cn/showproblem.php?pid=1237

AC代码：

#include<iostream>

#include<stack>

using namespace std;

int n;

char c;

int main(){

    scanf("%d",&n);

    getchar();

    while(n --){

        stack<char>s;
        while(1){
            c = getchar();
            if(c==' '||c==' '||c==EOF){
                while(!s.empty()){
                    printf("%c",s.top());
                    s.pop();
                }
                if(c==' '||c==EOF)break;
                printf(" ");
            }
            else
                s.push(c);
        }
        printf(" ");
    }
    return 0;
}

3.queue   先进先出

（1）在STL中只能通过front()来访问队首元素，或是通过back()来访问队尾元素。

（2）常用函数

　　push(x) //将x进行入队，时间复杂度为O(1)

　　front()、 back() //分别获得队首元素和队尾元素，时间复杂度为O(1)

　　pop() //令队首元素出队，时间复杂度为O(1)

　　empty() //检测队列是否为空，返回true为空，返回false为非空，时间复杂度O(1)

　　size() //返回栈中元素个数，时间复杂度O(1)

（3）常见用途

　　当需要实现BFS时，可以不用自己动手实现一个队列，而是用queue代替。

例题：http://acm.hdu.edu.cn/showproblem.php?pid=1702

#include<iostream>

#include<stack>

#include<queue>

#include<string>

using namespace std;

int t;  //次数

int main(){

    cin >> t;

    while(t --){

        stack<int> P;

        queue<int> Q;

        string s , s1;

        int n;

        int d;

        scanf("%d",&n);

        cin >> s ;

        if(s == "FIFO"){

            for(int i = 0; i<n;i++){

                cin >> s1;

                if(s1 == "IN"){
                    scanf("%d",&d);
                    Q.push(d);
                }

                if(s1 == "OUT"){
                    if(Q.empty())  printf("None ");
                    else{
                        cout << Q.front() << endl;
                        Q.pop();
                    }
                }
            }
        }

        if(s == "FILO"){

            for(int i = 0; i<n;i++){

                cin >> s1;

                if(s1 == "IN"){
                    scanf("%d",&d);
                    P.push(d);
                }

                if(s1 == "OUT"){
                    if(P.empty())  printf("None ");
                    else{
                        cout << P.top() << endl;
                        P.pop();
                    }
                }
            }
        }
    }
    return 0 ;
}

4.priority_queue 优先队列

  队首元素一定是当前队列中优先级最高的那个。和队列不一样的是优先队列没有front()和back()函数，只能通过top()函数来访问队首元素。

 

（1）常用函数

　　push(x)   //将x入队，时间复杂度为O(logN)，N为当前优先队列中的元素个数。

　　top()　　//获得队首元素，时间复杂度O(1)

　　pop()　　//令队首元素出队，时间复杂度为O(logN)，N为当前优先队列中的元素个数。

　　empty()　//检测优先队列是否为空，返回true则空，返回false则非空，时间复杂度O(1)。

　　size()　　//返回队列中元素的个数，时间复杂度O(1)。

 

（2）priority_queue内元素优先级设置

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

　　     优先队列对它们的优先级设置一般是数字大的优先级越高。如果是char型，则是字典序最大的。对基本数据类型来说下面两种是等价的：

　　　　1.priority_queue<int> q;

　　　　2.priority_queue<int , vector<int> , less<int > > q;  //less<int>表示数字大的优先级越大，而greater<int>表示数字小的优先级越大。

　　2.结构体优先级设置

　　     如：     struct fruit{

　　　　　　　　string name;

　　　　　　　　int price;

　　　　　　　　

　　　　　　　　friend bool operator < (fruit f1 , fruit f2){

　　　　　　　　　　return f1.price < f2.price;

　　　　　　　　}

　　　　　　　}

　　　　表示对操作符“<”进行了重载（重载大于号会编译错误，因为从数学上来说只需要重载小于号，即f1 > f2 等价于判断f2 < f1 , 而f1 == f2 等价于判断!(f1 < f2) && !(f2 < f1) ）

　　　　重载后小于号还是小于号的作用，此时内部就是以价格高的水果优先级高。

　　　　

　　　　同理，如果想以价格低的水果优先级高，只需要把return中的小于号改为大于号，即：

　　　　

　　　　　　struct fruit{

　　　　　　　　string name;

　　　　　　　　int price;

　　　　　　　　

　　　　　　　　friend bool operator < (fruit f1 , fruit f2){

　　　　　　　　　　return f1.price > f2.price;   //把小于号重载为大于号

　　　　　　　　}

　　　　　　　}

　　　　最后，如果结构体内数据较为庞大，建议使用引用来提高效率，此时比较类的参数中需要加上“const”和“&”如：

　　　　

　　　　　　struct fruit{

　　　　　　　　string name;

　　　　　　　　int price;

　　　　　　　　

　　　　　　　　friend bool operator < (const fruit &f1 ,const fruit &f2){

　　　　　　　　　　return f1.price > f2.price;   //把小于号重载为大于号

　　　　　　　　}

　　　　　　　}

　　3.priority_queue的常见用途

　　　　可以解决一些贪心问题，也可以对Dijkstra算法进行优化（因为优先队列的本质是堆）。

　　　　有一点需要注意，使用top()函数前，必须要empty()判断队列是否为空，否则可能因为队空而出现错误。

例题：http://acm.hdu.edu.cn/showproblem.php?pid=1873

AC代码：

#include<iostream>

#include<queue>

#include<string>

using namespace std;

struct node{

    int id ;

    int yxj ;

    friend bool operator < (const node &a,const node &b){  //保证B的优先级大于A

        if(a.yxj == b.yxj)  return a.id > b.id;

        return a.yxj < b.yxj;
    }

}N[1010];

priority_queue<node> doctor1;
priority_queue<node> doctor2;
priority_queue<node> doctor3;

int main(){

    int t , n , i , k;

    string s;

    while(scanf("%d",&n) != EOF){

        k = 1 ;
        for( i = 0 ; i < n ;i++){

            cin >> s;

            if(s == "IN"){
                N[i].id = k++;
                scanf("%d%d",&t,&N[i].yxj) ;

                if(t == 1) doctor1.push(N[i]);
                else if(t == 2)doctor2.push(N[i]);
                else if(t == 3)doctor3.push(N[i]);
            }
            else if(s == "OUT"){

                scanf("%d",&t);
                if(t == 1){
                    if(doctor1.empty()) cout<<"EMPTY"<<endl;

                    else{
                        cout << doctor1.top().id << endl;
                        doctor1.pop();
                    }
                }
                else if(t == 2){
                    if(doctor2.empty()) cout<<"EMPTY"<<endl;

                    else{
                        cout << doctor2.top().id << endl;
                        doctor2.pop();
                    }
                }
                else if(t == 3){
                    if(doctor3.empty()) cout<<"EMPTY"<<endl;

                    else{
                        cout << doctor3.top().id << endl;
                        doctor3.pop();
                    }
                }
            }
        }
    }
    return 0;
}

5.list

链表，高效率地在任意地方删除和插入，常数时间。

　　常用操作与vector类似。

例题：http://acm.hdu.edu.cn/showproblem.php?pid=1276

AC代码：

#include<iostream>
#include<list>
using namespace std;
int main()
{
    int t,n;
    cin>>t;
    while(t --)
    {
        cin >> n;
        int k = 2;
        list<int> l;
        list<int>::iterator it;
        for (int i = 1; i <= n; ++ i) l.push_back(i);
        while(l.size() > 3)
        {
            int num = 1;
            for (it = l.begin();it != l.end();)
            {
                if(num++ % k == 0) it = l.erase(it);   //该试结束后返回的是被删除元素的下一个元素的迭代器
                else it++;
            }
            k == 2?k = 3:k = 2;
        }
        for (it = l.begin();it != l.end();it++){
            if(it != l.begin()) cout<<" ";

            cout<<*it;
        }
        cout<<endl;
    }
    return 0;
}

6.set

　　1.set的定义

　　　　翻译为集合，是一个内部自动有序且不含重复元素的容器。set自动递增排序且自动去除了重复元素。需要用头文件#include<set> 和using namespace std;

　　2.元素的访问

　　　　set只能通过迭代器iterator访问

　　3.常用函数

　　　　1.insert(x)   //将x插入到set中，并自动递增排序和去重，时间复杂度为O(logN)

　　　　2.find(value)  //返回set中对应值为value的迭代器，时间复杂度O(logN)

　　　　3.erase()  //同vector 1.s.erase(it) //it为删除元素的迭代器,时间复杂度O（1）

　　　　　　　　　2.s.erase(value) //value是删除元素的值。时间复杂度O(logN)  　

　　　　4.size()

　　　　5.clear() //时间复杂度O(N)  N为元素个数

例题：http://acm.hdu.edu.cn/showproblem.php?pid=2094

AC代码：

#include <iostream>

#include<set>

using namespace std;

int main()
{
    set<string>a,b; //a存比赛人名，b存失败人名

    string s1,s2;
    int n;
    while(cin >> n && n)
    {
        for (int i = 0; i < n; ++i)
        {
            cin>>s1>>s2;
            a.insert(s1);
            a.insert(s2);
            b.insert(s2);
        }
        if (a.size()-b.size()==1) cout<<"Yes"<<endl;  //如果参赛人数比失败人数多一，那么比赛有一个人没失败，则必然是冠军
        else cout<<"No"<<endl;
        a.clear();b.clear();
    }
    return 0;
}

7.map

　　map翻译为映射，定义int a[100]数组时，实际上是定义了一个int型到int型的数组，如a[0] = 25,是将0映射到25.

　　

　　如果要用数组来表示“字符串->页码”这样的对应关系，就可以用到map。

 

　　map可以将任何基本类型（包括STL容器）映射到任何基本类型（包括STL容器）。

 

　　1.map的定义

　　　　需用到#include<map>;和using namespace std;

　　　　map<typename1 , typename2> mp;  实现从映射前类型 键（key）到映射后类型 值（value）的映射。

　　　    如果是字符串到整形的映射，必须用string而不能用char数组。

　　2.map容器内元素的访问

　　　　1.通过下标访问

　　　　　　和访问普通数组一样，如对一个定义为map<char , int> mp的map来说 ，就可以直接mp['c'] = 20来访问20。键是唯一的。

　　　　2.通过迭代器访问

　　　　　　map迭代器的定义： map<typename1 , typename2>::iterator it;

　　　　　　map迭代器是使用方式和其他STL容器不同，因为map的每一对映射都有两个typename，这就决定了必须能通过一个it来同时访问键和值。所以可以用it->first来访问键，it->second来访问值。

　　　　　　map会以键从小到大的顺序自动排序，这点和set一样

　　　　3.常用函数

　　　　　　1.find(key)  //返回键为key的映射的迭代器，时间复杂度为O(logN).

　　　　　　2.erase()

　　　　　　　　1.删除单个元素   

　　　　　　　　　　mp.erase(it),it为需要删除的元素的迭代器，时间复杂度O(1)

　　　　　　　　　　mp.erase(key) , key为想要删除的映射的键，时间复杂度O(logN)

　　　　　　　　2.删除一个区间内的所有元素

　　　　　　　　　　mp.erase(first , last),其中first是需要删除区间的歧视迭代器，last是需要删除的区间的末尾迭代器的下一个迭代器，也是左闭右开。时间复杂度O(last - first)

　　　　　　3.size()  //映射对数

　　　　　　4.clear()  //清空map中的所有元素，时间复杂度O(logN)

例题：http://acm.hdu.edu.cn/showproblem.php?pid=2648

AC代码：

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,p;
    map<string,int> shop;
    while(cin>>n)
    {
        string s;
        for (int i = 0; i < n; ++i) cin>>s;
        cin>>m;
        while(m--)
        {
            for (int i = 0; i < n; ++i)
            {
                cin>>p>>s;
                shop[s]+=p;
            }
            int rank = 1;
            map<string,int>::iterator it;
            for (it=shop.begin();it != shop.end(); ++it) if(it->second>shop["memory"]) rank++;
            cout<<rank<<endl;
        }
        shop.clear();
    }
    return 0;
}

 

8.sort()

　　排序函数

　　定义形式

　　　　sort(首元素地址（必填），尾元素地址的下一个地址（必填），比较函数（非必填）)  //默认为递增排序

　　　　比较函数写法：1.基本数据类型的排序  ，   例子，实现递减排序。

　　　　　　bool cmp(int a, int b){

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

　　　　　　}

　　　　　　　　　　　2.结构体数组的排序。

　　　　　　　　　　　　也是写一个比较函数，来规定按怎样的形式排序。

　　　　　　　　　　　3.容器的排序    

　　　　　　　　　　　　和基本数据类型的数组的写法大同小异。

 

9.next_permutation()

　　给出一个序列在全排列中的下一个序列。

例题：求全排列

int main(){

　　

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

　　sort(a, a+ 3);

　　do{

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

　　　　　　printf("%d",i);

　　　　　　printf(" ");

                }

　　}while(next_permutation(a , a + 3));

　　return 0;

}

 

 

啊啊啊啊啊啊阿，可算写完了，希望对大家有帮助，对自己有帮助！！！