zoukankan      html  css  js  c++  java
  • 275.算法设计工具―STL

    1.概述

    1.1定义

         STL主要由container(容器)、algorithm(算法)和iterator(迭代器)三大部分构成,容器用于存放数据对象(元素),算法用于操作容器中的数据对象。

    1.2stl容器

       一个STL容器就是一种数据结构,如链表、栈和队列等,这些数据结构在STL中都已经实现好了,在算法设计中可以直接使用它们。

     为此,使用STL时必须将下面的语句插入到源代码文件开头:

        using namespace std;

    这样直接把程序代码定位到std命名空间中。

    1.3STL算法

        STL算法是用来操作容器中数据的模板函数,STL提供了大约100个实现算法的模版函数。例如,STL用sort()来对一个vector中的数据(通用数据)进行排序,用find()来搜索一个list中的对象。

        STL算法部分主要由头文件<algorithm>、<numeric>和<functional>组成。

    例如,以下程序使用STL算法sort()实现整型数组a的递增排序:

    #include <algorithm>
    using namespace std; 
    void main()  
    {  int a[]={2,5,4,1,3};
       sort(a,a+5);
       for (int i=0;i<5;i++)
        printf("%d ",a[i]);    //输出: 1 2 3 4 5
       printf("
    ");
    }

    1.4stl迭代器

    指针的另一个说法

        STL迭代器用于访问容器中的数据对象。

        每个容器都有自己的迭代器,只有容器自己才知道如何访问自己的元素。

        迭代器像C/C++中的指针,算法通过迭代器来定位和操作容器中的元素。

    (整型指针只能指整型,向量指向量)

    常用的迭代器有:

    iterator:指向容器中存放元素的迭代器,用于正向遍历容器中的元素。

    const_iterator:指向容器中存放元素的常量迭代器,只能读取容器中的元素。

    reverse_iterator:指向容器中存放元素的反向迭代器,用于反向遍历容器中的元素。

    const_reverse_iterator:指向容器中存放元素的常量反向迭代器,只能读取容器中的元素。

    迭代器的常用运算如下:

    ++:正向移动迭代器。

    --:反向移动迭代器。

    *:返回迭代器所指的元素值。

    vector<int> myv;  //即将定义一个整型变量 
    myv.push_back(1); //push_back尾部插入
    myv.push_back(2);
    myv.push_back(3);  //向量的定义和变量的插入
    vector<int>::iterator it;    //定义正向迭代器it
    for (it=myv.begin();it!=myv.end();++it)
                    //从头到尾遍历所有元素  myv.end()最后一个元素的后面
        printf("%d ",*it);    //输出:1 2 3
    printf("
    ");
    vector<int>::reverse_iterator rit;
                    //定义反向迭代器rit
    for (rit=myv.rbegin();rit!=myv.rend();++rit)    
                    //从尾到头遍历所有元素   myv.rend()第一个元素的前面
        printf("%d ",*rit);    //输出:3 2 1
    printf("
    ");

    2.常用的STL容器

    顺序容器

    适配器容器

    关联容器

    2.1顺序容器

    2.1.1 vector(向量容器)

    1.定义

       它是一个向量类模板。向量容器相当于数组

       用于存储具有相同数据类型的一组元素,可以从末尾快速的插入与删除元素,快速地随机访问元素,但是在序列中间插入、删除元素较慢,因为需要移动插入或删除处后面的所有元素。

    定义vector容器的几种方式如下:

    vector<int> v1;        //定义元素为int的向量v1   相当于动态数组
    vector<int> v2(10);        //指定向量v2的初始大小为10个int元素
    vector<double> v3(101.23);    //指定v3的10个初始元素的初值为1.23
    vector<int> v4(a,a+5);    //用数组a[0..4]共5个元素初始化v4

    2.成员函数

    • vector提供了一系列的成员函数,vector主要的成员函数如下:
    • empty():判断当前向量容器是否为空。
    • size():返回当前向量容器的中的实际元素个数。
    • []:返回指定下标的元素。
    • reserve(n):为当前向量容器预分配n个元素的存储空间。
    • capacity():返回当前向量容器在重新进行内存分配以前所能容纳的元素个数。
    • resize(n) :调整当前向量容器的大小,使其能容纳n个元素。
    • push_back():在当前向量容器尾部添加了一个元素。
    • insert(pos,elem):在pos位置插入元素elem,即将元素elem插入到迭代器pos指定元素之前。
    • front():获取当前向量容器的第一个元素。
    • back():获取当前向量容器的最后一个元素。
    • erase():删除当前向量容器中某个迭代器或者迭代器区间指定的元素。
    • clear():删除当前向量容器中所有元素。
    • 迭代器函数:
      • begin():返回指向容器第一个元素的迭代器
      • end():返回指向容器最后元素(后面)的迭代器  
      • rbegin():倒数
      • rend():倒数

    调用方法:变量点函数  

    #include <vector>
    using namespace std;
    void main()
    {   vector<int> myv;        //定义vector容器myv
        vector<int>::iterator it;    //定义myv的正向迭代器it
        myv.push_back(1);        //在myv末尾添加元素1
        it=myv.begin();        //it迭代器指向开头元素1
        myv.insert(it,2);        //在it指向的元素之前插入元素2
        myv.push_back(3);        //在myv末尾添加元素3
        myv.push_back(4);        //在myv末尾添加元素4
        it=myv.end();        //it迭代器指向尾元素4的后面
        it--;            //it迭代器指向尾元素4
        myv.erase(it);        //删除元素4
        for (it=myv.begin();it!=myv.end();++it)
        printf("%d ",*it);
        printf("
    ");
    }
    //结果213

    2.1.2string(字符串容器)

    1.定义

        string是一个保存字符序列的容器,所有元素为字符类型,类似vector<char>。

        除了有字符串的一些常用操作以外,还有包含了所有的序列容器的操作。字符串的常用操作包括增加、删除、修改、查找比较、连接、输入、输出等。

    创建string容器的几种方式如下:

    char cstr[]="China! Greate Wall";    //C-字符串
    string s1(cstr);            // s1:China! Greate Wall
    string s2(s1);                // s2:China! Greate Wall
    string s3(cstr,711);        // s3:Greate Wall
    string s4(cstr,6);            // s4:China!
    string s5(5'A');            // s5:AAAAA

    2.常用的成员函数如下

    • empty():判断当前字符串是否为空串。
    • size():返回当前字符串的实际字符个数(返回结果为size_type类型)。
    • length():返回当前字符串的实际字符个数。
    • [idx]:返回当前字符串位于idx位置的字符,idx从0开始。
    • at(idx):返回当前字符串位于idx位置的字符。
    • compare(const string& str):返回当前字符串与字符串str的比较结果。在比较时,若两者相等,返回0;前者小于后者,返回-1;否则返回1。
    • append(cstr):在当前字符串的末尾添加一个字符串str。
    • insert(size_type idx,const string& str) :在当前字符串的idx处插入一个字符串str。
    • empty():判断当前字符串是否为空串。
    • size():返回当前字符串的实际字符个数(返回结果为size_type类型)。
    • length():返回当前字符串的实际字符个数。
    • [idx]:返回当前字符串位于idx位置的字符,idx从0开始。
    • at(idx):返回当前字符串位于idx位置的字符。
    • compare(const string& str):返回当前字符串与字符串str的比较结果。在比较时,若两者相等,返回0;前者小于后者,返回-1;否则返回1。
    • append(cstr):在当前字符串的末尾添加一个字符串str。
    • insert(size_type idx,const string& str) :在当前字符串的idx处插入一个字符串str。
    • 迭代器函数:begin()、end()、rbegin()最后一个元素后面、rend()第一个函数前面
    #include <iostream>
    #include <string> 
    using namespace std;
    void main() 
    {   string s1="",s2,s3="Bye";
        s1.append("Good morning");    //s1=" Good morning"
        s2=s1;                //s1=" Good morning"
        int i=s2.find("morning");        //i=5 查找i位置
        s2.replace(i,s2.length()-i,s3);    //相当于s2.replace(5,7,s3)
        cout << "s1: " << s1 << endl;  //s1=" Good morning"
        cout << "s2: " << s2 << endl;  //s1=" Good Bye"
    }

    求解模板生成工具问题。成成最近在搭建一个网站,其中一些页面的部分内容来自数据库中不同的数据记录,但是页面的基本结构是相同的。例如,对于展示用户信息的页面,当用户为Tom时,网页的源代码如下:

    而当用户为Jerry时,网页的源代码如下:

    这样的例子在包含动态内容的网站中还有很多。为了简化生成网页的工作,成成觉得他需要引入一套模板生成系统。模板是包含特殊标记的文本。成成用到的模板只包含一种特殊标记,格式为{{ VAR }},其中VAR是一个变量。该标记在模板生成时会被变量VAR的值所替代。例如,如果变量name = "Tom",则{{ name }}会生成Tom。具体的规则如下:

    变量名由大小写字母、数字和下划线(_)构成,且第一个字符不是数字,长度不超过16个字符。
    变量名是大小写敏感的,Name和name是两个不同的变量。
    变量的值是字符串。
    如果标记中的变量没有定义,则生成空串,相当于把标记从模板中删除。
    模板不递归生成。也就是说,如果变量的值中包含形如{{ VAR }}的内容,不再做进一步的替换。

     

    输入格式:输入的第一行包含两个整数m和n,分别表示模板的行数和模板生成时给出的变量个数。接下来m行,每行是一个字符串,表示模板。接下来n行,每行表示一个变量和它的值,中间用一个空格分隔。值是字符串,用双引号(")括起来,内容可包含除双引号以外的任意可打印 ASCII 字符(ASCII码范围32, 33, 35~126)。
    输出格式:输出包含若干行,表示模板生成的结果。

    样例输入:

    11 2
    <!DOCTYPE html>
    <html>
    <head>
    <title>User {{ name }}</title>
    </head>
    <body>
    <h1>{{ name }}</h1>
    <p>Email: <a
    href="mailto:{{ email }}">{{ email }}</a></p>
    <p>Address: {{ address }}</p>
    </body>
    </html>
    name "David Beckham"
    email "david@beckham.com"

    样例输出:

    <!DOCTYPE html>
    <html>
    <head>
    <title>User David Beckham</title>
    </head>
    <body>
    <h1>David Beckham</h1>
    <p>Email: <a
    href="mailto:david@beckham.com">david@beckham.com</a
    ></p>
    <p>Address: </p>
    </body>
    </html>

    评测用例规模与约定:

    0≤m≤100,0≤n≤100
    输入的模板每行长度不超过80个字符(不包含换行符)。
    输入保证模板中所有以 {{ 开始的子串都是合法的标记,开始是两个左大括号和一个空格,然后是变量名,结尾是一个空格和两个右大括号。
    输入中所有变量的值字符串长度不超过 100 个字符(不包括双引号)。
    保证输入的所有变量的名字各不相同。

    解:采用vector<string>向量content存放网页,每一行作为一个元素。用map<string,string>容器存放转换字符串。例如,对于题目中的样例,content向量中下标为0到10的元素如下:

    <!DOCTYPE html>
    <html>
    <head>
    <title>User {{ name }}</title>
    </head>
    <body>
    <h1>{{ name }}</h1>
    <p>Email: <a
    href="mailto:{{ email }}">{{ email }}</a></p>
    <p>Address: {{ address }}</p>
    </body>

    mymap映射容器中包含如下两个结点(注意双引号是值的一部分):

    mymap[email]= "david@beckham.com"
    mymap[name]= "David Beckham"

    然后扫描content的每个元素,查找形如“{{ var }}”的字符串,将{{ var }}用mymap[var]替换(注意替换部分不包含双引号),在一个元素中可以有多个需要替换的内容。例如,将:

    href="mailto:{{ email }}">{{ email }}</a></p>
    替换为:
    href="mailto:david@beckham.com">david@beckham.com</a></p>

    字符串查找、替换均采用string的成员函数完成。对应的程序如下:

    #include <iostream>
    #include <vector>
    #include <string>
    #include <map>
    using namespace std;
    vector<string> content;        //存放网页
    map<stringstring> mymap;        //存放转换字符串
    int m,n;
    void trans()            //网页转换
    {   for(int i=0;i<m;i++)        //转换content向量中的所有行
        {    int pos=0,pos1,pos2;
        do
        {   pos1=content[i].find("{{",pos);  
                          //从pos位置开始查找第一个{{
            pos2=content[i].find("}}",pos1);
                     //从pos1位置开始查找第一个}}
            if(pos1>=0 && pos2>=0)        //找到{{ }}
            {    string var=content[i].substr(pos1+3,pos2-pos1-4);
            if(mymap.count(var))        //提取形如{{var}}
            {   string result=mymap[var].substr(2,
                        mymap[var].length()-3);
                content[i].replace(pos1,var.length()+6,result); //替换
            }
            else
                 content[i].replace(pos1,var.length()+6"");
            pos=pos1+var.length();
            }
            else            //没有找到{{ }},pos指向当前字符串末尾
            pos = content[i].length();
        } while(pos<content[i].length());
         }
    }
    int main()
    {   int i; string line;
        cin >> m >> n;
        cin.ignore();        //屏蔽回车键
        for(i=0;i<m;i++)        //输入m行存放在content向量中
        {    getline(cin,line);
        content.push_back(line);
        }
        for(i=0;i<n;i++)        //输入n行按空格分为两个部分
        {    getline(cin,line);
        int pos = line.find(" ");    
        mymap.insert(map<stringstring>::value_type(
            line.substr(0,pos),line.substr(pos)));
        }
        trans();
        for (i=0;i<m;i++)        //输出网页转换结果
        cout << content[i] << endl;
        return 0;
    }

    2.1.3deque(双端队列容器)

    1.定义

    它是一个双端队列类模板。双端队列容器由若干个块构成,每个块中元素地址是连续的,块之间的地址是不连续的,有一个特定的机制将这些块构成一个整体。可以从前面或后面快速插入与删除元素,并可以快速地随机访问元素,但删除元素较慢。

    定义deque双端队列容器的几种方式如下:

    deque<int> dq1;    //定义元素为int的双端队列dq1
    deque<int> dq2(10);    //指定dq2的初始大小为10个int元素
    deque<double> dq3(101.23);
                //指定dq3的10个初始元素的初值为1.23
    deque<int> dq4(dq2.begin(),dq2.end());    
                //用dq2的所有元素初始化dq4

    2.deque主要的成员函数如下

    • empty():判断双端队列容器是否为空队。
    • size():返回双端队列容器中元素个数。
    • push_front(elem):在队头插入元素elem。
    • push_back(elem):在队尾插入元素elem。
    • pop_front():删除队头一个元素。
    • pop_back():删除队尾一个元素。
    • erase():从双端队列容器中删除一个或几个元素。
    • clear():删除双端队列容器中所有元素。
    • 迭代器函数:begin()、end()、rbegin()、rend()。
    #include <deque>
    using namespace std;
    void disp(deque<int> &dq)        //输出dq的所有元素
    {  deque<int>::iterator iter;        //定义迭代器iter
       for (iter=dq.begin();iter!=dq.end();iter++)
        printf("%d ",*iter);
       printf("
    ");
    }
    void main()
    {  deque<int> dq;            //建立一个双端队列dq
       dq.push_front(1);            //队头插入1
       dq.push_back(2);            //队尾插入2
       dq.push_front(3);            //队头插入3
       dq.push_back(4);            //队尾插入4
       printf("dq: "); disp(dq);
       dq.pop_front();            //删除队头元素
       dq.pop_back();            //删除队尾元素
       printf("dq: "); disp(dq);
    }

    //3124
    //12

    2.1.4list(链表容器)

    1.定义

    它是一个双链表类模板。可以从任何地方快速插入与删除。它的每个结点之间通过指针链接,不能随机访问元素。

    定义list容器的几种方式如下:

    list<int> l1;            //定义元素为int的链表l1
    list<int> l2 (10);        //指定链表l2的初始大小为10个int元素
    list<double> l3 (101.23);    //指定l3的10个初始元素的初值为1.23
    list<int> l4(a,a+5);        //用数组a[0..4]共5个元素初始化l4

    2.list的主要成员函数如下

    • empty():判断链表容器是否为空。
    • size():返回链表容器中实际元素个数。
    • push_back():在链表尾部插入元素。
    • pop_back():删除链表容器的最后一个元素。
    • remove ():删除链表容器中所有指定值的元素。
    • remove_if(cmp):删除链表容器中满足条件的元素。
    • erase():从链表容器中删除一个或几个元素。
    • unique():删除链表容器中相邻的重复元素。
    • clear():删除链表容器中所有的元素。
    • insert(pos,elem):在pos位置插入元素elem,即将元素elem插入到迭代器pos指定元素之前。
    • insert(pos,n,elem):在pos位置插入n个元素elem。
    • insert(pos,pos1,pos2):在迭代器pos处插入[pos1,pos2)的元素。
    • reverse():反转链表。
    • sort():对链表容器中的元素排序。
    • 迭代器函数:begin()、end()、rbegin()、rend()。

    说明:STL提供的sort()排序算法主要用于支持随机访问的容器,而list容器不支持随机访问,为此,list容器提供了sort()采用函数用于元素排序。类似的还有unique()、reverse()、merge()等STL算法。

    #include <list>
    using namespace std;
    void disp(list<int> &lst)        //输出lst的所有元素
    {  list<int>::iterator it;
       for (it=lst.begin();it!=lst.end();it++)
        printf("%d ",*it);
       printf("
    ");
    }
    void main()
    {  list<int> lst;            //定义list容器lst
       list<int>::iterator it,start,end;
       lst.push_back(5);            //添加5个整数5,2,4,1,3
       lst.push_back(2);  lst.push_back(4);
       lst.push_back(1);  lst.push_back(3);
       printf("初始lst: "); disp(lst);
       it=lst.begin();            //it指向首元素5
       start=++lst.begin();        //start指向第2个元素2
       end=--lst.end();            //end指向尾元素3
       lst.insert(it,start,end);
       printf("执行lst.insert(it,start,end)
    ");
       printf("插入后lst: "); disp(lst);
    }

    2.2关联容器

    2.2.1set(集合容器)/ multiset(多重集容器)

    1.定义

    set和multiset都是集合类模板,其元素值称为关键字。set中元素的关键字是唯一的,multiset中元素的关键字可以不唯一,而且默认情况下会对元素按关键字自动进行升序排列。
    查找速度比较快,同时支持集合的交、差和并等一些集合上的运算,如果需要集合中的元素允许重复那么可以使用multiset。

    2.set/multiset的成员函数如下

    • empty():判断容器是否为空。
    • size():返回容器中实际元素个数。
    • insert():插入元素。
    • erase():从容器删除一个或几个元素。
    • clear():删除所有元素。
    • count(k):返回容器中关键字k出现的次数。
    • find(k):如果容器中存在关键字为k的元素,返回该元素的迭代器,否则返回end()值。
    • upper_bound():返回一个迭代器,指向关键字大于k的第一个元素。
    • lower_bound():返回一个迭代器,指向关键字不小于k的第一个元素。
    • 迭代器函数:begin()、end()、rbegin()、rend()。
    #include <set>
    using namespace std;
    void main()
    {  set<int> s;            //定义set容器s
       set<int>::iterator it;    //定义set容器迭代器it
       s.insert(1);
       s.insert(3);
       s.insert(2);
       s.insert(4);
       s.insert(2);
       printf(" s: ");
       for (it=s.begin();it!=s.end();it++)
        printf("%d ",*it);
       printf("
    ");
    //s:1 2 3 4
       multiset<int> ms;    //定义multiset容器ms
       multiset<int>::iterator mit;
                //定义multiset容器迭代器mit
       ms.insert(1);
       ms.insert(3);
       ms.insert(2);
       ms.insert(4);
       ms.insert(2);
       printf("ms: ");
       for (mit=ms.begin();mit!=ms.end();mit++)
        printf("%d ",*mit);
       printf("
    ");
    }
    //ms:1 2 2 3 4

    2.2.2map(映射容器)/ multimap(多重映射容器)

    1.定义

    类似于数组,关键字当成下标

    map和multimap都是映射类模板。映射是实现关键字与值关系的存储结构,可以使用一个关键字key来访问相应的数据值value。
    在set/multiset中的key和value都是key类型,而key和value是一个pair类结构。
    pair类结构的声明形如:

    struct pair
    { 
        T first;
        T second;
    }

    map/multimap利用pair的<运算符将所有元素即key-value对按key的升序排列,以红黑树的形式存储,可以根据key快速地找到与之对应的value(查找时间为O(log2n))。
    map中不允许关键字重复出现,支持[]运算符;而multimap中允许关键字重复出现,但不支持[]运算符。

    2.map/multimap的主要成员函数如下

    empty():判断容器是否为空。
    size():返回容器中实际元素个数。
    map[key]:返回关键字为key的元素的引用,如果不存在这样的关键字,则以key作为关键字插入一个元素(不适合multimap)。
    insert(elem):插入一个元素elem并返回该元素的位置。
    clear():删除所有元素。
    find():在容器中查找元素。
    count():容器中指定关键字的元素个数(map中只有1或者0)。
    迭代器函数:begin()、end()、rbegin()、rend()。

    在map中修改元素非常简单,这是因为map容器已经对[]运算符进行了重载(对其含义进行重新定义)。例如:

    map<char,int> mymap;    //定义map容器mymap,其元素类型为pair<char,int>
    mymap['a'] = 1;                //或者mymap.insert(pair<char,int>('a',1) );
    //键字符型‘单引号’ 值int

    获得map中一个值的最简单方法如下:

    int ans = mymap['a'];

    只有当map中有这个关键字('a')时才会成功,否则会自动插入一个元素,值为初始化值。可以使用find() 方法来发现一个关键字是否存在。

    #include <map>
    using namespace std;
    void main()
    {   map<char,int> mymap;    //定义map容器mymap
        mymap.insert(pair<char,int>('a',1));
                    //插入方式1
        mymap.insert(map<char,int>::value_type('b',2));
                    //插入方式2
        mymap['c']=3;                                
    //插入方式3 map<char,int>::iterator it; for(it=mymap.begin();it!=mymap.end();it++) printf("[%c,%d] ",it->first,it->second); printf(" "); } //[a,1] [b,2] [c,3]

    2.3适配器容器

    2.3.1stack(栈容器)

    它是一个栈类模板,和数据结构中的栈一样,具有后进先出的特点。栈容器默认的底层容器是deque。也可以指定其他底层容器。
    例如,以下语句指定myst栈的底层容器为vector:

    stack<string,vector<string> > myst;    
                    //第2个参数指定底层容器为vector

    stack容器主要的成员函数如下:

    • empty():判断栈容器是否为空。
    • size():返回栈容器中实际元素个数。
    • push(elem):元素elem进栈。
    • top():返回栈顶元素。
    • pop():元素出栈。

    注意:stack容器没有begin()/end()和rbegin()/rend()这样的用于迭代器的成员函数。

    #include <stack>
    using namespace std;
    void main()
    {  stack<int> st;
       st.push(1); st.push(2); st.push(3);
       printf("栈顶元素: %d
    ",st.top());
       printf("出栈顺序: ");
       while (!st.empty())     //栈不空时出栈所有元素
       {    printf("%d ",st.top());
        st.pop() ;
       }
       printf("
    ");
    }

    2.3.2queue(队列容器)

    它是一个队列类模板,和数据结构中的队列一样,具有先进先出的特点。不允许顺序遍历,没有begin()/end()和rbegin()/rend()这样的用于迭代器的成员函数。

    主要的成员函数如下:

    • empty():判断队列容器是否为空。
    • size():返回队列容器中实际元素个数。
    • front():返回队头元素。
    • back():返回队尾元素。
    • push(elem):元素elem进队。
    • pop():元素出队。
    #include <queue>
    using namespace std;
    void main()
    {  queue<int> qu;
       qu.push(1); qu.push(2); qu.push(3);
       printf("队头元素: %d
    ",qu.front());
       printf("队尾元素: %d
    ",qu.back());
       printf("出队顺序: ");
       while (!qu.empty())        //出队所有元素
       {    printf("%d ",qu.front());
        qu.pop();
       }
       printf("
    ");
    }

    2.3.3priority_queue(优先队列容器)

    它是一个优先队列类模板。优先队列是一种具有受限访问操作的存储结构,元素可以以任意顺序进入优先队列。
    一旦元素在优先队列容器中,出队操作将出队列最高优先级元素。

    主要的成员函数如下:

    • empty():判断优先队列容器是否为空。
    • size():返回优先队列容器中实际元素个数。
    • push(elem):元素elem进队。
    • top():获取队头元素。
    • pop():元素出队。
    #include <queue>
    using namespace std;
    void main()
    {   priority_queue<int> qu;
        qu.push(3); qu.push(1); qu.push(2);
        printf("队头元素: %d
    ",qu.top());
        printf("出队顺序: ");
        while (!qu.empty())        //出队所有元素
        {    printf("%d ",qu.top());
        qu.pop();
        }
        printf("
    ");
    }

    3.STL在算法设计中的应用

    3.1存放主数据

    算法设计重要步骤是设计数据的存储结构,除非特别指定,程序员可以采用STL中的容器存放主数据,选择何种容器不仅要考虑数据的类型,还有考虑数据的处理过程。
    例如,字符串可以采用string或者vector<char>来存储,链表可以采用list来存储。

    【例1.11】有一段英文由若干单词组成,单词之间用一个空格分隔。编写程序提取其中的所有单词。
    解:这里的主数据是一段英文,采用string字符串str存储它,最后提取的单词采用vector<string>容器words存储。

    #include <iostream>
    #include <string>
    #include <vector>
    using namespace std;
    void solve(string str,vector<string> &words) //产生所有单词words
    {  string w;
       int i=0;
       int j=str.find(" ");    //查找第一个空格
       while (j!=-1)        //找到单词后循环
       {    w=str.substr(i,j-i);    //提取一个单词,从i到j-i在str里面取
        words.push_back(w);    //单词添加到words中
        i=j+1;
        j=str.find(" ",i);    //查找下一个空格
       }
       if (i<str.length()-1)    //处理最后一个单词
       {    
         w=str.substr(i); //提取最后一个单词    words.push_back(w); //最后单词添加到words中 } }
    void main() 
    {  string str="The following code computes the 
            intersection of two arrays";
       vector<string> words;
       solve(str,words);
       cout << "所有的单词:" << endl;    //输出结果
       vector<string>::iterator it;
       for (it=words.begin();it!=words.end();++it)
        cout << "  " << *it << endl;
    }
    所有的单词:
       The
       following
       code
       computes
       the
       intersection
       of
       two
       arrays

    3.2存放临时数据

    在算法设计中,有时需要存放一些临时数据。通常的情况是,如果后存入的元素先处理,可以使用stack栈容器;
    如果先存入的元素先处理,可以使用queue队列容器;如果元素处理顺序按某个优先级进行,可以使用priority_queue优先队列容器。

    【例1.12】设计一个算法,判断一个含有()、[]、{}三种类型括号的表达式中所有括号是否匹配。
    解:这里的主数据是一个字符串表达式,采用string字符串str存储它。在判断括号是否匹配时需要用到一个栈(因为每个右括号都是和前面最近的左括号匹配),采用stack<char>容器作为栈。

    #include <iostream>
    #include <stack>
    #include <string>
    using namespace std;
    bool solve(string str)        //判断str中括号是否匹配
    {  stack<char> st;
       int i=0;
       while (i<str.length())        //扫描str的所有字符
       {    if (str[i]=='(' || str[i]=='[' || str[i]=='{')
           st.push(str[i]);        //所有左括号进栈
        else if (str[i]==')')        //当前字符为')'
        {   if (st.top()!='(')    //若栈顶不是匹配的'(',返回假
            return false;
            else            //若栈顶是匹配的'(',退栈
            st.pop();
        }
        else if (str[i]==']')        //当前字符为']'
        {  if (st.top()!='[')        //若栈顶不是匹配的'[',返回假
            return false;
           else                //若栈顶是匹配的'[',退栈
            st.pop();
        }
        else if (str[i]=='}')        //当前字符为'}'
        {   if (st.top()!='{')    //若栈顶不是匹配的'{',返回假
            return false;
            else            //若栈顶是匹配的'{',退栈
            st.pop();
        }
        i++;
        }
        if (st.empty())            //str处理完毕并且栈空返回真
        return true;
        else
        return false;            //否则返回假
    }
    void main() 
    {  cout << "求解结果:" << endl;
       string str="(a+[b-c]+d)";
       cout << "  " << str << 
            (solve(str)?"中括号匹配":"中括号不匹配") << endl;
       str="(a+[b-c}+d)";
       cout << "  " << str << 
            (solve(str)?"中括号匹配":"中括号不匹配") << endl;
    }
    /*
    (a+[b-c]+d) 中括号匹配
    (a+[b-c}+d) 中括号不匹配
    */

    3.3检测数据元素的唯一性

    可以使用map容器或者哈希表容器检测数据元素是否唯一或者存放累计个数。

    【例1.13】设计一个算法判断字符串str中每个字符是否唯一。如,"abc"的每个字符是唯一的,算法返回true,而"accb"的中字符'c'不是唯一的,算法返回false。


    解:设计map<char,int>容器mymap,第一个分量key的类型为char,第二个分量value的类型为int,表示对应关键字出现的次数。
    将字符串str中每个字符作为关键字插入到map容器中,插入后对应出现次数增1。如果某个字符的出现次数大于1,表示不唯一,返回false;如果所有字符唯一,返回true。

    bool isUnique(string &str)    //检测str中的所有字符是否唯一的
    {  map<char,int> mymap;
       for (int i=0;i<str.length();i++)
       {    
         mymap[str[i]]
    ++;   if (mymap[str[i]]>1)   return false; } return true; }

    求多少对相反数。有N个非零且各不相同的整数。请你编一个程序求出它们中有多少对相反数(a和-a为一对相反数)。时间限制为1.0s,内存限制:256.0MB。
    输入格式:第一行包含一个正整数 N(1≤N≤500)。第二行为N个用单个空格隔开的非零整数,每个数的绝对值不超过1000,保证这些整数各不相同。
    输出格式:只输出一个整数,即这N个数中包含多少对相反数。
    样例输入:
    5
    1 2 3 -1 -2
    样例输出:
    2

    解:可以直接采用暴力思路求解,但可能超时。
    这里使用STL的map容器mymap(其实用哈希表效率更高),对于输入的负整数x,将(-x,1)插入。扫描所有输入的正整数y,当mymap[y]存在时说明对应一个相反数对,ans增1。

    #include <stdio.h>
    #include <map>
    using namespace std;
    #define MAX 505
    int main()
    {   int ans=0;        //累计相反数对的个数
        int n,x,i;
        int a[MAX];
        map<intint> mymap;
        scanf("%d",&n);
        for (i=0;i<n;i++)
        {    scanf("%d",&x);
        a[i]=x;
        if (x<0)    //将负整数插入mymap
           mymap.insert(pair<intint>(-x,1));
        }
        for (i=0;i<n;i++)
        if (a[i]>0 && mymap[a[i]])
            ans++;
        printf("%d
    ",ans);
    }

    3.4数据排序

    对于list容器的元素排序可以使用其成员函数sort(),对于数组或者vector等具有随机访问特性的容器,可以使用STL算法sort()。
    下面以STL算法sort()为例讨论。

    1)内置数据类型的排序
    对于内置数据类型的数据,sort()默认是以less<T>(小于关系函数)作为关系函数实现递增排序。
    为了实现递减排序,需要调用<functional>头文件中定义的greater类模板。
    例如,以下程序使用greater<int>()实现vector<int>容器元素的递减排序(其中sort(myv.begin(),myv.end(),less<int>())语句等同于sort(myv.begin(),myv.end()),实现默认的递增排序):

    #include <iostream>
    #include <algorithm>
    #include <vector>
    #include <functional>            //包含less、greater等
    using namespace std;
    void Disp(vector<int> &myv)        //输出vector的元素
    {  vector<int>::iterator it;
       for(it = myv.begin();it!=myv.end();it++)
        cout << *it << " ";
       cout << endl;
    }
    void main()
    {  int a[]={2,1,5,4,3};
       int n=sizeof(a)/sizeof(a[0]);
       vector<int> myv(a,a+n);
       cout << "初始myv:  "; Disp(myv);    //输出:2 1 5 4 3
       sort(myv.begin(),myv.end(),less<int>());
       cout << "递增排序: "; Disp(myv);    //输出:1 2 3 4 5
       sort(myv.begin(),myv.end(),greater<int>());
       cout << "递减排序: "; Disp(myv);    //输出:5 4 3 2 1
    }

    2)自定义数据类型的排序
    对于自定义数据类型如结构体数据,同样默认是less<T>(即小于关系函数)作为关系函数,但需要重载该函数。另外还可以自己定义关系函数()。在这些重载函数或者关系函数中指定数据的排序顺序(按哪些结构体成员排序,是递增还是递减)。
    归纳起来,实现排序时主要有两种方式:

    方式1:在声明结构体类型中重载<运算符,以实现按指定成员的递增或者递减排序。如sort(myv.begin(),myv.end())调用默认<运算符对myv容器的所有元素实现排序。
    方式2:自己定义关系函数(),以实现按指定成员的递增或者递减排序。如sort(myv.begin(),myv.end(),Cmp())调用Cmp的()运算符对myv容器的所有元素实现排序。

    #include <iostream>
    #include <algorithm>
    #include <vector>
    #include <string>
    using namespace std;
    struct Stud
    {  int no;
       string name;
       Stud(int no1,string name1)    //构造函数
       {    no=no1;
        name=name1;
       }
       bool operator<(const Stud &s) const    //方式1:重载<运算符
       {
        return s.no<no;   //用于按no递减排序,将<改为>则按no递增排序
       }
    };
    struct Cmp            //方式2:定义关系函数()
    {  bool operator()(const Stud &s,const Stud &t) const
       {
        return s.name<t.name; 
            //用于按name递增排序,将<改为>则按name递减排序
       }
    };
    void Disp(vector<Stud> &myv)    //输出vector的元素
    {   vector<Stud>::iterator it;
        for(it = myv.begin();it!=myv.end();it++)
        cout << it->no << "," << it->name << "	";
        cout << endl;
    }
    void main()
    {  Stud a[]={Stud(2,"Mary"),Stud(1,"John"),Stud(5,"Smith")};
       int n=sizeof(a)/sizeof(a[0]);
       vector<Stud> myv(a,a+n);
       cout << "初始myv:    "; Disp(myv);  
                //输出:2,Mary   1,John  5,Smith
       sort(myv.begin(),myv.end());      //默认使用<运算符排序
       cout << "按no递减排序:   "; Disp(myv);    
                //输出:5,Smith  2,Mary  1,John
       sort(myv.begin(),myv.end(),Cmp());  //使用Cmp中的()运算符进行排序
       cout << "按name递增排序: "; Disp(myv);
                //输出:1,John   2,Mary  5,Smith
    }

    3.5优先队列作为堆

    在有些算法设计中用到堆,堆采用STL的优先队列来实现,优先级的高低由队列中数据元素的关系函数(比较运算符)确定,很多情况下需要重载关系函数。

    1)元素为内置数据类型的堆
    对于C/C++内置数据类型,默认是less<T>(小于关系函数)作为关系函数,值越大优先级的越高(即大根堆),可以改为以greater<T>作为关系函数,这样值越大优先级的越低(即小根堆)。
    例如,以下程序中pq1为大根堆(默认),pq2为小根堆(通过greater<int>实现):

    #include <iostream>
    #include <queue>
    using namespace std;
    void main()
    {  int a[]={3,6,1,5,4,2};
       int n=sizeof(a)/sizeof(a[0]);
       //(1)优先级队列pq1默认是使用vector作容器
       priority_queue<int> pq1(a,a+n);
       cout << "pq1: ";
       while (!pq1.empty())
       {    cout << pq1.top() << " ";    //while循环输出:6 5 4 3 2 1
        pq1.pop();
       }
       cout << endl;
       //(2)优先级队列pq2使用vector作容器,int元素的关系函数改为greater
       priority_queue<int,vector<int>,greater<int> > pq2(a,a+n);
       cout << "pq2: ";
       while (!pq2.empty())
       {    cout << pq2.top() << " ";    //while循环输出:1 2 3 4 5 6
        pq2.pop();
       }
       cout << endl;
    }

    2)元素为自定义类型的堆
    对于自定义数据类型如结构体数据,同样默认是less<T>(即小于关系函数)作为关系函数,但需要重载该函数。
    另外还可以自己定义关系函数()。在这些重载函数或者关系函数中指定数据的优先级(优先级取决于哪些结构体,是越大越优先还是越小越优先)。

    #include <iostream>
    #include <queue>
    #include <string>
    using namespace std;
    struct Stud                    //声明结构体Stud
    {  int no;
       string name;
       Stud(int n,string na)            //构造函数
       {    no=n;
        name=na;
       }
       bool operator<(const Stud &s) const    //重载<关系函数
       {    return no<s.no;  }
       bool operator>(const Stud &s) const    //重载>关系函数
       {    return no>s.no;  }
    };
    //结构体的关系函数,改写operator()
    struct StudCmp
    {   bool operator()(const Stud &s,const Stud &t) const
        {
        return s.name<t.name;        //name越大越优先
        }
    };
    void main()
    {  Stud a[]={Stud(2,"Mary"),Stud(1,"John"),Stud(5,"Smith")};
       int n=sizeof(a)/sizeof(a[0]);
       //(1)使用Stud结构体的<关系函数定义pq1
       priority_queue<Stud> pq1(a,a+n);
       cout << "pq1出队顺序: ";
       while (!pq1.empty())        //按no递减输出
       {    cout << "[" << pq1.top().no << "," << 
                pq1.top().name << "]	";
        pq1.pop();
       }
       cout << endl;
    //pq1出队顺序: [5,Smith]   [2,Mary]    [1,John]
        //(2)使用Stud结构体的>关系函数定义pq2
        priority_queue<Stud,deque<Stud>,greater<Stud> > pq2(a,a+n);
        cout << "pq2出队顺序: ";
        while (!pq2.empty())            //按no递增输出
        {    cout << "[" << pq2.top().no << "," << 
                pq2.top().name << "]	";
        pq2.pop();
        }
        cout << endl;
    //pq2出队顺序: [1,John]    [2,Mary]    [5,Smith]
    
        //(3)使用结构体StudCmp的关系函数定义pq3
       priority_queue<Stud,deque<Stud>,StudCmp > pq3(a,a+n);
       cout << "pq3出队顺序: ";
       while (!pq3.empty())        //按name递减输出
       {    cout << "[" << pq3.top().no << "," 
                << pq3.top().name << "]	";
        pq3.pop();
       }
       cout << endl;
    }
    //pq3出队顺序: [5,Smith]   [2,Mary]    [1,John]

  • 相关阅读:
    组合数据类型练习
    实验四、递归下降语法分析实验
    词法分析实验报告
    Python基础综合练习
    大数据概述
    一个词法分析程序
    linux基本命令
    有限自动机的构造与识别
    我对编译原理的小小了解
    Scrum 冲刺博客 2
  • 原文地址:https://www.cnblogs.com/ZanderZhao/p/11497562.html
Copyright © 2011-2022 走看看