STL之vector与deque比较

来源：互联网发布：淘宝卖编辑：程序博客网时间：2024/06/18 11:01

之所以专门把STL中的这两个拿出来说一说，是因为vector和deque都是支持随机访问的，其支持的迭代器类型都为随机访问，而不像map,set,list等都是支持双向迭代器的。

vector,deuqe之对比：

1：随机访问速度：vector > deque。

2；deque性能损失比vector高几个数量级：因为deque首次插入一个元素时，会默认动态分配512字节空间，当这512字节空间用完后，它会再动态分配自己另外的512字节空间，然后虚拟地连在一起。deque的这种设计使得它具有比vector复杂得多的架构、算法和迭代器设计，也使得性能损失比vector高！

3:在插入删除操作时，deque由于vector:对于vector而言，由于其是一端开口，所以在尾部插入耗费固定的时间，而在头部进行插入时，耗费的时间与vector的大小成正比，vector越大，耗费的时间越多。而对于deque,不管插入删除操作是在头部还是尾部进行，算法的效率是固定的。

只看不写的程序员不是优秀的程序员，下面我们用代码来说明上述问题：

先看vector的：

01int main()  
02{   
03    struct timeb tb1,tb2;         //定义时间，以便计算程序前后的执行时间
04    unsigned int real_time = 0;
05 
06    ifstream ifs("test1.txt");     //我在test1.txt里存放了一百万个数
07    ofstream ofs("test2.txt");         //将整理后的数据存放到test2.txt里
08    istream_iterator<int> ibeg(ifs);  
09    istream_iterator<int> iend;        //无参数默认为end
10    ostream_iterator<int> iwrt(ofs," ");    
11    vector<int> vec(ibeg, iend);        //定义vector
12 
13    ftime(&tb1);
14    sort(vec.begin(),vec.end());        //对一百万个数据进行排序
15    copy(vec.begin(),vec.end(),iwrt);    //写入到目标文件内
16     
17    ftime(&tb2);
18    real_time = tb2.millitm - tb1.millitm + (tb2.time - tb1.time)*1000;//得到完成排序和写入操作的执行时间
19    cout<<"vector time is "<<real_time<<"ms"<<endl;    
20    return 0;  
21}

执行后输出结果为：vector time is 1646ms。

我们再来看看deque的代码：

01int main()
02{
03    struct timeb qtb1,qtb2;
04    unsigned qreal_time = 0;
05 
06    ifstream ifs("test1.txt");
07    ofstream ofs("test3.txt");      //将处理后的数据写入到test3.txt内
08    istream_iterator<int> qbeg(ifs);
09    istream_iterator<int> qend;
10    ostream_iterator<int> qwrt(ofs," ");
11    deque<int> deq(qbeg,qend);   
12 
13    ftime(&qtb1);
14    sort(deq.begin(),deq.end());
15    copy(deq.begin(),deq.end(),qwrt);
16 
17    ftime(&qtb2);
18    qreal_time = qtb2.millitm - qtb1.millitm + (qtb2.time - qtb1.time)*1000;
19    cout<<"deque time is "<<qreal_time<<"ms"<<endl;
20    return 0;
21}

执行后输出结果为：deque time is 4396ms；

可以看出，在顺序访问上，vector的速度是优于deque的。

我们再来看看插入的时候，同样先看vector的插入：

01int main()  
02{   
03    struct timeval tb1,tb2,tb3;
04    unsigned int real_time = 0;
05 
06    ifstream ifs("test2.txt");     //在test2.txt的一百万个数据间操作
07    istream_iterator<int> ibeg(ifs);  
08    istream_iterator<int> iend;
09    vector<int> vec(ibeg, iend);
10 
11    gettimeofday(&tb1,NULL);
12    vec.insert(vec.begin(),1);   //在开头位置插入
13     
14    gettimeofday(&tb2,NULL);
15    real_time = tb2.tv_usec - tb1.tv_usec + (tb2.tv_sec - tb1.tv_sec)*1000;                     //获取开头位置插入所耗时间
16    cout<<"vector head time is "<<real_time<<"us"<<endl;
17 
18    vec.insert(vec.end(),1);    //在末尾位置插入
19    gettimeofday(&tb3,NULL);
20    real_time = tb3.tv_usec - tb2.tv_usec + (tb3.tv_sec - tb2.tv_sec)*1000;                   //在末尾位置插入所耗时间
21    cout<<"veator end time is "<<real_time<<"us"<<endl;
22 
23    return 0;  
24}

执行之后，打印结果为：vector head time is 780 us

vector end time is 87us

我们再来看看 deque的：

01int main()
02{
03    struct timeval qtb1,qtb2,qtb3;
04    unsigned qreal_time = 0;
05 
06    ifstream ifs("test3.txt");
07    istream_iterator<int> qbeg(ifs);
08    istream_iterator<int> qend;
09    deque<int> deq(qbeg,qend);
10 
11    gettimeofday(&qtb1,NULL);
12    deq.insert(deq.begin(),1);             //在开头插入
13 
14    gettimeofday(&qtb2,NULL);
15    qreal_time = qtb2.tv_usec - qtb1.tv_usec + (qtb2.tv_sec - qtb1.tv_sec)*1000000;
16    cout<<"deque head time is "<<qreal_time<<"us"<<endl;
17 
18    deq.insert(deq.end(),1);               //在末尾插入
19    gettimeofday(&qtb3,NULL);
20    qreal_time = qtb3.tv_usec - qtb2.tv_usec + (qtb3.tv_sec - qtb2.tv_sec)*1000000;  
21    cout<<"deque end time is "<<qreal_time<<"us"<<endl;
22    return 0;
23}

执行之后，打印结果为：deque head time is 1us

deque end time is 62us

可以得到，在vector和deque进行插入删除时，deque的效率是高于vector的。当都是在末尾进行插入时，vector和deque的差别不大，但是在对头部进行插入时，差距十分明显。

上面的几条差不多也就论述完了。

总结一下：当进行插入删除时候，选择deque，当进行顺序访问时，选择vector；

0 0