常用STL容器及算法举例

转载自：http://blog.csdn.net/shouhuqi/article/details/7431863

一 常用容器举例 

1 vector：

       vector类似于动态数组，直接访问元素，从后面快速插入或者删除，示例代码如下：

[cpp]
view plain
copy

#include <iostream>  
#include <vector>//包含vector  
using namespace std;//指定命名空间  
  
int main()  
{  
    cout<<"----------vector test-----------"<<endl;  
      
    //定义一个vector  
    vector <int> vect;  
    vector <int> vect1(12);//12个int类型元素，每个元素的初始值均为0  
    vector <int> vect2(12,9);//12个int，初试值均为9  
      
  
    //使用数组初始化vector  
    int a[]={0,1,2,3,4,5,6,7,8,9,0};  
    //vector <数据类型> <容器名> (<开始地址>,<结束地址的下一个地址> )。执行过vt中元素为1,2,3  
    vector <int> vt(a+1,a+4);  
    //在尾部压入3个值  
    vt.push_back(1);  
    vt.push_back(2);  
    vt.push_back(3);  
  
    //定义迭代器iterator  
    vector <int>::iterator iter=vt.begin();//起始地址  
    vector <int>::iterator iter_end=vt.end();//结束地址,两个地址都是指针类型  
    //遍历vt  
    for(;iter!=iter_end;iter++)  
    {  
        cout<<*iter<<endl;  
    }  
      
    //弹出一个元素  
    vt.pop_back();  
      
    //以下两行重新获得起始和结尾地址  
    iter=vt.begin();  
    iter_end=vt.end();  
    cout<<"----------executed pop_back------"<<endl;  
    for(;iter!=iter_end;iter++)  
    {  
        cout<<*iter<<endl;  
    }  
  
    //插入元素  
    cout<<"----------insert into------------"<<endl;  
    //插入格式：vector.insert(<起始地址>,<插入的数量>,<元素值>);如果插入的数量为1，则第二个参数可以被省略  
    vt.insert(vt.begin()+1,3,9);  
    iter=vt.begin();  
    iter_end=vt.end();  
    for(;iter!=iter_end;iter++)  
    {  
        cout<<*iter<<endl;  
    }  
      
    //删除元素  
    cout<<"----------erase-------------------"<<endl;  
    //删除格式1为：vector.erase(<删除元素的地址>);  
    //删除格式2为：vector.erase(<删除元素的起始地址>，<终止地址>);  
    iter=vt.begin();  
    iter_end=vt.end();  
    vt.erase(iter+1,iter_end);//删除第二个到最后一个的元素  
    iter_end=vt.end();  
    for(;iter!=iter_end;iter++)  
    {  
        cout<<*iter<<endl;  
    }  
    return 1;  
}  

   2  list

  list 为双向链表，可以从任何地方插入或者删除的，其示例代码如下：

[cpp]
view plain
copy

#include <iostream>  
#include <list>  
using namespace std;  
  
void main()  
{  
    list<int> c1;  
    c1.push_back(1);//从尾部push数据（结点）到list中   
    c1.push_back(2);   
    c1.push_back(3);  
    c1.push_back(4);  
      
    c1.push_front(0);//从头部push数据（结点）到list中   
      
    c1.pop_back();//从尾部pop数据（结点）出去   
    int& i = c1.back();//获取list中尾部数据（结点）   
    const int& ii = c1.front();//获取list中头部 数据（结点）  
      
      
    cout << "The last integer of c1 is " << i << endl;  
    cout << "The front interger of c1 is " << ii << endl;  
      
    cout << "for循环读出数据举例：" << endl;  
    //循环遍历数据举例  
    list<int>::iterator it; //定义遍历指示器(类似于int i=0)   
    for(it = c1.begin() ; it != c1.end() ;it++)  
    {  
        cout << *it << endl;  
    }  
    system("pause");  
}  

3 deque：

 deque: 是一个double-ended queue,

 1)支持随即存取，也就是[]操作符，

 2)支持两端操作，push(pop)-back(front)，在两端操作上与list效率差不多

 因此在实际使用时，如何选择这三个容器中哪一个，应根据你的需要而定，一般应遵循下面的原则： 

 1、如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector 

2、如果你需要大量的插入和删除，而不关心随即存取，则应使用list 

3、如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque。

示例代码如下：

[cpp]
view plain
copy

/*deque: 是一个double-ended queue, 
    1)支持随即存取，也就是[]操作符， 
    2)支持两端操作，push(pop)-back(front)，在两端操作上与list效率差不多 
 
    因此在实际使用时，如何选择这三个容器中哪一个，应根据你的需要而定，一般应遵循下面的原则：  
    1、如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector  
    2、如果你需要大量的插入和删除，而不关心随即存取，则应使用list  
    3、如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque。 
*/  
  
#include <iostream>  
#include <deque>  
using namespace std;  
  
void printDeque(const deque<int>& d)  
{  
    cout<<"\n使用下标:\n";  
    for (unsigned int i = 0; i < d.size(); i++)  
    {  
    cout<<"d["<<i<<"] = "<<d[i]<<", ";  
    }  
  
  
    cout<<"\n使用迭代器\n";  
    deque<int>::const_iterator iter = d.begin();  
    for (;iter != d.end(); iter ++)  
    {  
    cout<<"d["<<iter-d.begin()<<"] = "<<(*iter)<<", ";  
    }  
    cout<<endl;  
}  
  
void main()  
{  
//创建deque  
deque<int> d1;                          //创建一个没有任何元素的deque对象  
deque<int> d2(10);                      //创建一个具有10个元素的deque对象，每个元素值为默认  
deque<double> d3(10, 5.5);              //创建一个具有10个元素的deque对象,每个元素的初始值为5.5  
deque<double> d4(d3);                   //通过拷贝一个deque对象的元素值, 创建一个新的deque对象  
  
//初始化赋值：同vector一样,使用尾部插入函数push_back()  
for (int i = 1; i < 6 ; i++)  
   d1.push_back(i*10);  
  
  
//遍历元素: 1-下标方式 2-迭代器方式 反向遍历（略）  
cout<<"printDeque(d1) : "<<endl;  
printDeque(d1);  
  
//元素插入：尾部插入用push_back()，头部插入用push_front()，其它位置插入用insert(&pos, elem)  
cout<<"d1.push_front(100): "<<endl;  
d1.push_front(100);  
printDeque(d1);  
cout<<"d1.insert(d1.begin()+3, 200): "<<endl; //支持随机存取(即[]操作符)，所以begin()可以+3  
d1.insert(d1.begin()+2,200);  
printDeque(d1);  
  
//元素删除 尾部删除用pop_back();头部删除用pop_front();   
//任意迭代位置或迭代区间上的元素删除用erase(&pos)/erase(&first, &last)；删除所有元素用clear();  
cout<<"d1.pop_front(): "<<endl;  
d1.pop_front();  
printDeque(d1);  
  
cout<<"d1.erase(d1.begin()+1): "<<endl;  
d1.erase(d1.begin()+1); //删除第2个元素d1[1]  
printDeque(d1);  
  
cout<<"d1.erase(d1.begin(), d1.begin() + 2) = "<<endl;  
d1.erase(d1.begin(), d1.begin() + 2);  
printDeque(d1);  
  
cout<<"d1.clear() :"<<endl;  
d1.clear();  
printDeque(d1);  
  
  
  
}  

4 容器适配器：stack

（1）可用 vector, list, deque来实现

（2）缺省情况下，用deque实现      

template<classT, class Cont = deque<T> > 

               class stack {    …..    }；

（3）用 vector和deque实现，比用list实现性能好

（4）stack是后进先出的数据结构，

（5）只能插入、删除、访问栈顶的元素的操作: push:    插入元素pop:      弹出元素     
top:返回栈顶元素的引用

测试代码如下：

[cpp]
view plain
copy

<span style="font-size:16px;">#include <iostream>  
#include <Stack>  
using namespace std;  
  
void main()  
{  
    stack<double> s;//可以是各种数据类型；  
    for( int i=0; i < 10; i++ )  
        s.push(i);  
    while(!s.empty())  
    {  
        printf("%lf\n",s.top());  
        s.pop();  
    }  
    cout << "the size of  s: " << s.size() << endl;  
}  
</span>  

5 deque

可以用 list和deque实现，缺省情况下用deque实现

          template<class T, class Cont = deque<T>>

           class queue {  …  };

 FIFO先进先出的数据结构，也有push,pop,top函数，但是push发生在队尾，pop,top发生在队头，

示例代码如下：

[cpp]
view plain
copy

/************************************************************************/  
/*  
 
详细用法: 
定义一个queue的变量     queue<Type> M 
查看是否为空范例        M.empty()    是的话返回1，不是返回0; 
从已有元素后面增加元素   M.push() 
输出现有元素的个数      M.size() 
显示第一个元素          M.front() 
显示最后一个元素        M.back() 
清除第一个元素          M.pop() 
                                                                     */  
/************************************************************************/  
  
#include <iostream>  
#include <queue>  
#include <assert.h>  
  
using namespace std;  
  
int main()  
{  
    queue <int> myQ;  
    int i;  
    cout<< "现在 queue 是否 empty? "<< myQ.empty() << endl;   
      
    for( i =0; i<10 ; i++)  
    {  
        myQ.push(i);  
    }  
    for( i=0; i<myQ.size(); i++)  
    {  
        printf("myQ.size():%d\n",myQ.size());  
        cout << myQ.front()<<endl;  
        myQ.pop();  
    }  
      
    system("PAUSE");   
      
    return 0;  
}  

二 常用算法

1  count（）and  count_if()

 count()在序列中统计某个值出现的次数
 count_if()在序列中统计与某谓词匹配的次数
示例代码如下：

[cpp]
view plain
copy

#include <iostream>  
#include <algorithm>  
#include <functional>  
#include <string>  
#include <vector>  
  
using namespace std;  
  
  
void CountFuc()  
{  
    const int VECTOR_SIZE = 8 ;  
      
    // Define a template class vector of strings  
    typedef vector<string > StringVector ;  
      
    //Define an iterator for template class vector of strings  
    typedef StringVector::iterator StringVectorIt ;  
      
    StringVector NamesVect(VECTOR_SIZE) ;   //vector containing names  
      
    string value("Sea") ;  // stores the value used  
    // to count matching elements  
      
    StringVectorIt start, end, it ;  
      
    int result = 0 ;   // stores count of elements  
    // that match value.  
      
    // Initialize vector NamesVect  
    NamesVect[0] = "She" ;  
    NamesVect[1] = "Sells" ;  
    NamesVect[2] = "Sea" ;  
    NamesVect[3] = "Shells" ;  
    NamesVect[4] = "by" ;  
    NamesVect[5] = "the" ;  
    NamesVect[6] = "Sea" ;  
    NamesVect[7] = "Shore" ;  
      
    start = NamesVect.begin() ;   // location of first  
    // element of NamesVect  
      
    end = NamesVect.end() ;       // one past the location  
    // last element of NamesVect  
      
    // print content of NamesVect  
    cout << "NamesVect { " ;  
    for(it = start; it != end; it++)  
        cout << *it << " " ;  
    cout << " }\n" << endl ;  
      
    // Count the number of elements in the range [first, last +1)  
    // that match value.  
    result = count(start, end, value) ;  
      
    // print the count of elements that match value  
    cout << "Number of elements that match \"Sea\" = "  
        << result << endl  ;  
}  
  
  
int MatchFirstChar( const string& str)  
{  
    string s("S") ;  
    return s == str.substr(0,1) ;  
}  
  
  
void CountIfFuc()  
{  
    const int VECTOR_SIZE = 8 ;  
      
    // Define a template class vector of strings  
    typedef vector<string > StringVector ;  
      
    //Define an iterator for template class vector of strings  
    typedef StringVector::iterator StringVectorIt ;  
      
    StringVector NamesVect(VECTOR_SIZE) ;   //vector containing names  
      
    StringVectorIt start, end, it ;  
      
    int result = 0 ;   // stores count of elements  
    // that match value.  
      
    // Initialize vector NamesVect  
    NamesVect[0] = "She" ;  
    NamesVect[1] = "Sells" ;  
    NamesVect[2] = "Sea" ;  
    NamesVect[3] = "Shells" ;  
    NamesVect[4] = "by" ;  
    NamesVect[5] = "the" ;  
    NamesVect[6] = "Sea" ;  
    NamesVect[7] = "Shore" ;  
      
    start = NamesVect.begin() ;   // location of first  
    // element of NamesVect  
      
    end = NamesVect.end() ;       // one past the location  
    // last element of NamesVect  
      
    // print content of NamesVect  
    cout << "NamesVect { " ;  
    for(it = start; it != end; it++)  
        cout << *it << " " ;  
    cout << " }\n" << endl ;  
      
    // Count the number of elements in the range [first, last +1)  
    // that start with letter 'S'  
    result = count_if(start, end, MatchFirstChar) ;  
      
    // print the count of elements that start with letter 'S'  
    cout << "Number of elements that start with letter \"S\" = "  
        << result << endl  ;  
}  
  
  
void main()  
{  
    CountFuc();  
    CountIfFuc();  
}  

 

2 find and  find_if

  find       在序列中找出某个值的第一次出现的位置

  find_if     在序列中找出符合某谓词的第一个元素
示例代码如下：

[cpp]
view plain
copy

#include <algorithm>  
#include <iostream>  
  
using namespace std;  
  
  
void FindFuc()  
{  
    const int ARRAY_SIZE = 8 ;  
    int IntArray[ARRAY_SIZE] = { 1, 2, 3, 4, 4, 5, 6, 7 } ;  
      
    int *location ;   // stores the position of the first  
    // matching element.  
      
    int i ;  
      
    int value = 4 ;  
      
    // print content of IntArray  
    cout << "IntArray { " ;  
    for(i = 0; i < ARRAY_SIZE; i++)  
        cout << IntArray[i] << ", " ;  
    cout << " }" << endl ;  
      
    // Find the first element in the range [first, last + 1)  
    // that matches value.  
    location = find(IntArray, IntArray + ARRAY_SIZE, value) ;  
      
    //print the matching element if any was found  
    if (location != IntArray + ARRAY_SIZE)  // matching element found  
        cout << "First element that matches " << value  
        << " is at location " << location - IntArray << endl;  
    else                                    // no matching element was  
        // found  
        cout << "The sequence does not contain any elements"  
        << " with value " << value << endl ;  
}  
  
int IsOdd( int n)  
{  
    return n % 2 ;  
}  
  
  
void FindIfFuc()  
{  
    const int ARRAY_SIZE = 8 ;  
    int IntArray[ARRAY_SIZE] = { 1, 2, 3, 4, 4, 5, 6, 7 } ;  
    int *location ;   // stores the position of the first  
    // element that is an odd number  
    int i ;  
      
    // print content of IntArray  
    cout << "IntArray { " ;  
    for(i = 0; i < ARRAY_SIZE; i++)  
        cout << IntArray[i] << ", " ;  
    cout << " }" << endl ;  
      
    // Find the first element in the range [first, last -1 ]  
    // that is an odd number  
    location = find_if(IntArray, IntArray + ARRAY_SIZE, IsOdd) ;  
      
    //print the location of the first element  
    // that is an odd number  
    if (location != IntArray + ARRAY_SIZE)  // first odd element found  
        cout << "First odd element " << *location  
        << " is at location " << location - IntArray << endl;  
    else         // no odd numbers in the range  
        cout << "The sequence does not contain any odd numbers"  
        << endl ;  
  
}  
  
  
void main()  
{  
    FindFuc();  
    FindIfFuc();  
}  

3 for_each()

函数声明如下：

template<class InIt, class Fun>
Fun for_each(InIt first, InIt last, Fun f);

          在区间【first，last）上的每个元素执行f操作
示例代码如下：

[cpp]
view plain
copy

#include <iostream>  
#include <vector>  
#include <algorithm>  
  
using namespace std;  
  
  
// prints the cube of integer n  
void PrintCube(int n)  
{  
    cout << n * n * n << " " ;  
}  
  
void main()  
{  
    const int VECTOR_SIZE = 8 ;  
      
    // Define a template class vector of integers  
    typedef vector<int > IntVector ;  
      
    //Define an iterator for template class vector of integer  
    typedef IntVector::iterator IntVectorIt ;  
      
    IntVector Numbers(VECTOR_SIZE) ;   //vector containing numbers  
      
    IntVectorIt start, end, it ;  
      
    int i ;  
      
    // Initialize vector Numbers  
    for (i = 0; i < VECTOR_SIZE; i++)  
        Numbers[i] = i + 1 ;  
      
    start = Numbers.begin() ;   // location of first  
    // element of Numbers  
      
    end = Numbers.end() ;       // one past the location  
    // last element of Numbers  
      
    // print content of Numbers  
    cout << "Numbers { " ;  
    for(it = start; it != end; it++)  
        cout << *it << " " ;  
    cout << " }\n" << endl ;  
      
    // for each element in the range [first, last)  
    // print the cube of the element  
    for_each(start, end, PrintCube) ;  
    cout << "\n\n" ;  
}  

 

4 unique

  unique --常用来删除重复的元素，将相邻的重复的元素移到最后，返回一个iterator指向最后的重复元素，所以用它来删除重复元素时必须先排序
示例代码如下：

[cpp]
view plain
copy

#include <iostream>  
#include <algorithm>  
#include <vector>  
#include <string>  
using namespace std;  
  
  
void main()  
{  
    string str;  
    vector<string> words;  
    while(cin>>str&&str!="#")  
    {  
        words.push_back(str);  
    }  
      
    sort(words.begin(),words.end());  
    vector<string>::iterator end_unique =  
        unique(words.begin(),words.end());  
    words.erase(end_unique,words.end());  
      
      
    vector<string> ::iterator ite=words.begin();  
    for(;ite!=words.end();ite++)  
    {  
        cout<<*ite<<"   ";  
    }  
      
    cout<<endl;  
}  

 

5 常用排序算法

常用排列算法如下：

1 sort    对给定区间所有元素进行排序 

2 stable_sort  对给定区间所有元素进行稳定排序 

3 partial_sort  对给定区间所有元素部分排序 

4 partial_sort_copy 对给定区间复制并排序
示例代码如下：

[cpp]
view plain
copy

#include <iostream>  
#include <algorithm>  
#include <stdlib.h>  
#include <time.h>  
#include <VECTOR>  
using namespace std;  
  
  
const int N=10;  
  
void print(const vector<int>& v)  
{  
    vector<int>::const_iterator ite=v.begin();  
    for(;ite!=v.end();ite++)  
    {  
        cout<<*ite<<"  ";  
    }  
  
    cout<<endl;  
}  
  
void Create(vector<int>& v)  
{  
    srand((unsigned int)time(NULL));  
    v.resize(N);  
    for(int i=0;i<N;i++)  
        v[i]=rand()%100;  
}  
  
  
// bool cmp(int arg1,int arg2)  
// {  
//  return arg1<arg2;  
// }  
  
  
void sort1(vector<int> v)  
{  
    sort(v.begin(),v.end());  
    cout<<"after sort funtion:\n";  
    print(v);  
}  
  
void sort2(vector<int> v)  
{  
    stable_sort(v.begin(),v.end());  
    cout<<"after stable_sort funtion:\n";  
    print(v);  
}  
  
void sort3(vector<int> v)  
{  
    partial_sort(v.begin(),v.begin()+v.size()/2,v.end()); //对前半部分排序  
    cout<<"after partial_sort funtion:\n";  
    print(v);  
}  
  
void sort4(vector<int> v)  
{  
    vector<int> temp;  
    temp.resize(v.size());  
    partial_sort_copy(v.begin(),v.end(),temp.begin(),temp.end()); //复制并排序  
    cout<<"after partial_sort_copy funtion:\n";  
    print(temp);  
}  
  
  
void main()  
{  
    vector<int> v;  
  
    Create(v);  
    cout<<"before sort:\n";  
    print(v);  
  
    sort1(v);  
    sort2(v);  
    sort3(v);  
    sort4(v);  
}  

6 生成全排列

next_permutation（）的原型如下：
template<class BidirectionalIterator>
bool next_permutation(
BidirectionalIterator _First,
BidirectionalIterator _Last
);

template<class BidirectionalIterator, class BinaryPredicate>
bool next_permutation(
BidirectionalIterator _First,
BidirectionalIterator _Last,
BinaryPredicate _Comp
);

两个重载函数,第二个带谓词参数_Comp,其中只带两个参数的版本,默认谓词函数为"小于".，返回值为bool类型
示例代码如下：

[cpp]
view plain
copy

#include <iostream>  
#include <algorithm>  
using namespace std;  
  
void permutation(char* str,int length)  
{  
    sort(str,str+length);  
    do  
    {  
        for(int i=0;i<length;i++)  
            cout<<str[i];  
        cout<<endl;  
    }while(next_permutation(str,str+length));  
      
}  
int main(void)  
{  
    char str[] = "acb";  
    cout<<str<<"所有全排列的结果为："<<endl;  
    permutation(str,3);  
    system("pause");  
    return 0;  
}  

（注 ：以上所有代码在vc6.0上测试通过）