STL之迭代器，序列容器, 算法

   一、迭代器

    1、迭代器（iterator）相当于指向容器元素的指针,迭代器在容器中可以向前移动，可以向前向后双向移动，有专为输入元素准备的迭代器，也有专为输出元素准备的迭代器，还有可以进行随机操作的迭代器。迭代器（iterator）为访问容器提供了通用方法。

    2、输出迭代器：只用于写一个序列，这种类型的迭代器可以进行递增和提取操作

         实例：int main()

{

    vector<int> intvect;//定义一个存放整形的容器

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

        intvect.push_back(++i);//插入数据

    }

    cout << "Vect:" << endl;

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

    while(it!=intvect.end())

        cout<<*it++<<"  ";

    cout<<endl;

    system("pause");

    return 0;

}

   3、输出迭代器：只用于读一个序列，这种类型的迭代器可以进行递增、提取和比较操作

         实例：int main()

{

    vector<int> intvect(5);//定义一个内存大小为5的整形的容器

    vector<int>::iterator it=intvect.begin();//迭代器指向容器的首地址

    *it++=1;

    *it++=3;

    *it++=5;

    *it++=7;

    *it++=9;

    cout << "Vect:" << endl;

    vector<int>::iterator out=intvect.begin();

    while(out!=intvect.end()){

         cout<<*out++<<"  ";

    }

    cout<<endl;

    system("pause");

    return 0;

}

    4、前向迭代器：既可以读，也可以写。这种迭代器不仅具有输入和输出迭代器功能，还具有保存其值的功能，从而能够从迭代器原来的位置开始重新遍历序列

       实例：保存值的功能

int main()

{

    vector<int> intvect(5);//定义一个内存大小为5的整形的容器

    vector<int>::iterator it=intvect.begin();//迭代器指向容器的首地址

    vector<int>::iterator saveIt=it;//用于保存值

    *it++=11;

    *it++=13;

    *it++=15;

    *it++=17;

    *it=9;

    cout << "Vect:" << endl;

    while(saveIt!=intvect.end()){

         cout<<*saveIt++<<"  ";

    }

    cout<<endl;

    system("pause");

    return 0;

}

    5、双向迭代器：与前向迭代器类似，同时具有递增和递减操作

       实例：int main()

{

    vector<int> intvect(5);//定义一个内存大小为5的整形的容器

    vector<int>::iterator it=intvect.begin();//迭代器指向容器的首地址

    vector<int>::iterator saveIt=it;//用于保存值

    *it++=11;

    *it++=13;

    *it++=15;

    *it++=17;

    *it=9;

    cout << "Vect:" << endl;

    while(saveIt!=intvect.end()){

         cout<<*saveIt++<<"  ";

    }

    cout<<endl;

    do{

        cout<<*--saveIt<<"  ";

    }while(saveIt!=intvect.begin());

    cout<<endl;

    system("pause");

    return 0;

}

    6、随机访问迭代器：最强大的迭代器类型，不仅具有双向迭代器的所有功能，还能使用指针的算术运算和所有比较运算

       实例：int main()

{

    vector<int> intvect(5);//定义一个内存大小为5的整形的容器

    vector<int>::iterator it=intvect.begin();//迭代器指向容器的首地址

    *it++=1;

    *it++=3;

    *it++=5;

    *it++=7;

    *it++=9;

    cout << "Vect Old:" << endl;

    for(it=intvect.begin();it!=intvect.end();it++){

        cout<<*it<<"  ";

    }

    cout<<endl;

    it=intvect.begin();//重新指向首地址

    *(it+2)=100; // 修改容器内的数

    cout << "Vect:" << endl;

    for(it=intvect.begin();it!=intvect.end();it++){

        cout<<*it<<"  ";

    }

    cout<<endl;

    system("pause");

    return 0;

}

二、序列容器

    STL提供了很多容器，每种容器都提供一组操作行为，序列容器（sequence容器）只能提供插入功能，序列容器中的容器都是有序的，但并未排序，序列容器包括vcetor向量、deque双端队列和list双向串行。

     1、向量容器

        向量（vector）是一种随机访问的数组类型，提供了对数组元素的快速随机访问，以及在序列尾部快速、随机的插入、删除操作。它在需要时可以改变其大小，是大小可变的向量。

     2、双端队列类模板

       双端队列（deque）是一种随机访问的数组类型，提供了在序列两端快速插入和删除操作的功能，它在需要时可以改变其大小，双端队列主要完成标准C++数据结构中队列的功能。

     3、链表类模板

       链表（list）,双向链表容器，它不支持随机访问，访问链表元素要指针从链表的某个端点开始，插入和删除所花的时间固定，和该元素在链表中的位置无关，在任何位置插入和删除动作都很快，不像vector只能在末尾进行操作。

      4、实例

      （1）向量容器（vector）

#include<vector>

#include<algorithm>

void output(char val)

{

    cout<<val<<"  ";

}

void Output(int val)

{

    cout<<val<<" ";

}

void OutPut(double val)

{

    cout<<val<<" ";

}

int main()

{

    vector<char> character;//创建字符型向量容器

    character.push_back('Z');//往向量中插入数据

    character.push_back('B');

    character.push_back('A');

    character.push_back('G');

    character.push_back('H');

    character.push_back('F');

    cout<<"contents of vector:"<<endl;

    for_each(character.begin(),character.end(),output);//循环显示向量中的元素

    cout<<endl;

    sort(character.begin(),character.end());//对向量中的元素进行排序

    cout<<"contents of vector:"<<endl;

    for_each(character.begin(),character.end(),output);//循环显示排序后向量中的元素

    cout<<endl;

    vector<int> intvect;//创建整型向量容器

    intvect.push_back(2);//往向量中插入数据

    intvect.push_back(9);

    intvect.push_back(3);

    intvect.push_back(-1);

    intvect.push_back(5);

    intvect.push_back(7);

    cout<<"contents of vector:"<<endl;

    for_each(intvect.begin(),intvect.end(),Output);//循环显示向量中的元素

    cout<<endl;

    sort(intvect.begin(),intvect.end());//对向量中的元素进行排序

    cout<<"contents of vector:"<<endl;

    for_each(intvect.begin(),intvect.end(),Output);//循环显示排序后向量中的元素

    cout<<endl;

    vector<double> douvect;//创建浮点型向量容器

    douvect.push_back(2.1);//往向量中插入数据

    douvect.push_back(9.3);

    douvect.push_back(3.6);

    douvect.push_back(-1.8);

    douvect.push_back(0.5);

    douvect.push_back(7.1);

    cout<<"contents of vector:"<<endl;

    for_each(douvect.begin(),douvect.end(),OutPut);//循环显示向量中的元素

    cout<<endl;

    sort(douvect.begin(),douvect.end());//对向量中的元素进行排序

    cout<<"contents of vector:"<<endl;

    for_each(douvect.begin(),douvect.end(),OutPut);//循环显示排序后向量中的元素

    cout<<endl;

    system("pause");

    return 0;
}

      （2）双端队列（deque）

#include<deque>

int main()

{

    deque<int> intdeque;//创建整型双端队列

    intdeque.push_back(2);

    intdeque.push_back(5);

    intdeque.push_back(7);

    intdeque.push_back(9);

    intdeque.push_back(13);

    cout<<"deque old:"<<endl;

    for(int i=0;i<intdeque.size();i++){

        cout<<"intdeque["<<i<<"]:";

        cout<<intdeque[i]<<endl;

    }

    cout<<endl;

    intdeque.pop_front();//删除队列中的元素

    intdeque.pop_front();

    intdeque[1]=33;

    cout<<"deque new:"<<endl;

    for(int i=0;i<intdeque.size();i++){

        cout<<"intdeque["<<i<<"]:";

        cout<<intdeque[i]<<endl;

    }

    system("pause");

    return 0;

}

      （3）链表容器（list）

    #include<list>

int main()

{

    char cTemp;

    list<char> charlist;//创建字符型链表容器

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

        cTemp='a'+i;

        charlist.push_front(cTemp);//插入数据

    }

    cout<<"list old:"<<endl;

    list<char>::iterator it;

    for(it=charlist.begin();it!=charlist.end();it++){

        cout<<*it<<endl;

    }

    list<char>::iterator itstart=charlist.begin();

    charlist.insert(++itstart,2,'A');//新插入的数据

    cout<<"list new:"<<endl;

//    list<char>::iterator it;

    for(it=charlist.begin();it!=charlist.end();it++){

        cout<<*it<<endl;

    }

    system("pause");

    return 0;

}

三、算法

     算法是STL的中枢，STL提供了算法库，算法中都是模板函数，迭代器主要负责从容器那获取一个对象，算法算法不关心具体对象在容器中什么位置等细节，每个算法都是参数化一个或多个迭代器类型的函数模板。

     标准算法分四个类别：非修正序列算法、修正序列算法、排序算法和数值算法。

     1、非修正序列算法：不修改它们所作用的容器，例如计算元素个数或查找元素的函数。

     2、修正序列算法：有些操作会修改容器的内容，例如，把一个容器的部分内容拷贝到同一个容器的另一部分，或者用指定值填充容器，STL的变异算法提供了这类操作。

     3、排序算法：特点是对容器的内容进行不同方式的排序。

     4、数值算法：对容器的内容进行数值计算。