vector,list,deque的比较

最新推荐文章于 2023-07-12 13:09:32 发布
最新推荐文章于 2023-07-12 13:09:32 发布
阅读量970 收藏 1
点赞数 1
文章标签： vector list random null 测试 each
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adropofsnow/article/details/6232502
版权

C++的STL模板库中提供了3种容器类：vector,list,deque
对于这三种容器，在觉得好用的同时，经常会让我们困惑应该选择哪一种来实现我们的逻辑。
在少量数据操作的程序中随便哪一种用起来感觉差别并不是很大，
但是当数据达到一定数量后，会明显感觉性能上有很大差异。

本文就试图从介绍，以及性能比较两个方面来讨论这个问题。

 

  1. vector - 会自动增长的数组
  2. list - 擅长插入删除的链表
  3. deque - 拥有vector和list两者优点的双端队列
  4. 性能竞技场
  5. 性能总结与使用建议
  6. 测试程序清单

vector - 会自动增长的数组

vector又称为向量数组，他是为了解决程序中定义的数组是
不能动态改变大小这个缺点而出现的。
一般程序实现是在类创建的时候同时创建一个定长数组，
随着数据不断被写入，一旦数组被填满，则重新开辟一块更大的内存区，
把原有的数据复制到新的内存区，抛弃原有的内存，如此反复。

由于程序自动管理数组的增长，对于我们程序员来说确实轻松了不少，
只管把数据往里面插就行了，当然把物理内存和虚拟内存插爆掉了
就是操作系统来找你麻烦了:-)

vector由于数组的增长只能向前，所以也只提供了后端插入和后端删除，
也就是push_back和pop_back。当然在前端和中间要操作数据也是可以的，
用insert和erase，但是前端和中间对数据进行操作必然会引起数据块的移动，
这对性能影响是非常大的。

对于所有数组来说，最大的优势就是随机访问的能力。
在vector中，提供了at和[]运算符这两个方法来进行随机访问。
由于每个数据大小相同，并且无间隔地排列在内存中，
所以要对某一个数据操作，只需要用一个表达式就能直接计算出地址：
address = base + index * datasize

同样，对vector进行内存开辟，初始化，清除都是不需要花大力气的，
从头到尾都只有一块内存。

list - 擅长插入删除的链表

有黑必有白，世界万物都是成对出现的。
链表对于数组来说就是相反的存在。
数组本身是没有动态增长能力的（程序中也必须重新开辟内存来实现），
而链表强悍的就是动态增长和删除的能力。
但对于数组强悍的随机访问能力来说的话，链表却很弱。

list是一个双向链表的实现。
为了提供双向遍历的能力，list要比一般的数据单元多出两个指向前后的指针。
这也是没办法的，毕竟现在的PC内存结构就是一个大数组，
链表要在不同的环境中实现自己的功能就需要花更多空间。

list提供了push_back，push_front，pop_back，pop_front四个方法
来方便操作list的两端数据的增加和删除，不过少了vector的at和[]运算符的
随机访问数据的方法。并不是不能实现，而是list的设计者
并不想让list去做那些事情，因为他们会做得非常差劲。

对于list来说，清除容器内所有的元素是一件苦力活，
因为所有数据单元的内存都不连续，list只有一个一个遍历来删除。

deque - 拥有vector和list两者优点的双端队列

黑与白，处于这两个极端之间的就是令人愉悦的彩色了。
deque作为vector和list的结合体，确实有着不凡的实力。

STL的deque的实现没有怎么去看过，不过根据我自己的猜测，
应该是把数组分段化，在分段的数组上添加指针来把所有段连在一起，
最终成为一个大的数组。

deque和list一样，提供了push_back，push_front，
pop_back，pop_front四个方法。可以想象，如果要对deque的两端进行操作，
也就是要对第一段和最后一段的定长数组进行重新分配内存区，
由于分过段的数组很小，重新分配的开销也就不会很大。

deque也和vector一样，提供了at和[]运算符的方法。
要计算出某个数据的地址的话，虽然要比vector麻烦一点，
但效率要比list高多了。
首先和list一样进行遍历，每次遍历的时候累积每段数组的大小，
当遍历到某个段，而且baseN <= index < baseN + baseN_length的时候，
通过address = baseN + baseN_index就能计算出地址
由于分过段的后链表的长度也不是很长，所以遍历对于
整体性能的影响就微乎其微了。

看起来deque很无敌吧，不过deque和希腊神话的阿吉里斯一样，
再怎么强大也是有自己的弱点的，之后的测试数据中就能看到了。


 

性能竞技场

为了能更好地进行比较，我们让静态数组（程序中写死的）和
动态数组（程序中new出来的）也参加了部分竞技。

竞技项目：
  • 初始化：对于静态和动态数组，逐一赋值，对于容器，push_back插入
  • 前向遍历：从0到n-1，每个数据自加1
  • 后向遍历：从n-1到0，每个数据自减1
  • 随机访问：在0到n-1中，随机抽取一定数量的数据进行读取
  • 后端插入：用push_back在后端插入一定数量的数据
  • 后端移除：用pop_back在后端移除一定数量的数据
  • 前端插入：用push_front在前端插入一定数量的数据
  • 前端移除：用pop_front在前端移除一定数量的数据
  • 中间插入：用insert在中间插入一定数量的数据
  • 中间移除：用erase在中间移除一定数量的数据
  • 反初始化：对于静态和动态数组，ZeroMemory删除所有数据，对于容器，调用clear方法
规则：
  • vector，list，deque都调用默认的构造函数来创建
  • 数组和容器的数据项都是1,000,000个
  • 前端和后端插入的数据项是10,000个
  • 前端和后端删除的数据项是10,000个
  • 随机访问的数据项是10,000个
  • 数据类型采用int型
  • 计时采用RDTSC高精度计时器来计时
  • 随机访问的数据的位置序列在测试前随机生成，所有数组和容器都采用这个序列
  • 测试采用Debug版(Release版会对代码进行优化，可能会对测试产生一定的影响)
  • 测试3次，取平均值
测试机配置：
Intel(R) Core(TM)2 CPU T7400 2.16GHz 2.16GHz
2.00GB内存

测试结果：（单位 秒）
测试项目静态数组动态数组vectorlistdeque备注
　初始化0.005510.004610.2071.300.352list每个数据项都有附加数据，速度稍慢了一些
前向遍历0.003810.005490.07960.07560.0713 
后向遍历0.004220.004780.8850.8790.690 
随机访问0.0003340.0003420.001191480.0115list把时间都耗在了找寻相应数据上
后端插入N/AN/A0.001920.01280.00260 
后端移除N/AN/A0.001310.02930.00194 
前端插入N/AN/A10.20.01280.00547vector对前端操作很苦手啊
前端移除N/AN/A10.30.02970.00135同上
中间插入N/AN/A195187764看似万能的deque的最大弱点，因为复杂的结构导致中间数据操作带来的复杂性大大增加，体现在操作时间是其他两个的几倍
中间移除N/AN/A195209753同上
反初始化0.001390.002900.00001060.6930.305vector貌似是直接抛弃内存的，其他两个就没那么简单了

 

性能总结与使用建议

测试项目静态数组动态数组vectorlistdeque
　初始化★★★★★★★★★★★★★★☆★★★☆☆★★★★☆
前向遍历★★★★★★★★★★★★★★☆★★★★☆★★★★☆
后向遍历★★★★★★★★★★★★★★☆★★★★☆★★★★☆
随机访问★★★★★★★★★★★★★★☆★☆☆☆☆★★★☆☆
后端插入N/AN/A★★★★★★★★★☆★★★★★
后端移除N/AN/A★★★★★★★★★☆★★★★★
前端插入N/AN/A★★☆☆☆★★★★☆★★★★★
前端移除N/AN/A★★☆☆☆★★★★☆★★★★★
中间插入N/AN/A★★☆☆☆★★☆☆☆★☆☆☆☆
中间移除N/AN/A★★☆☆☆★★☆☆☆★☆☆☆☆
反初始化★★★★★★★★★★★★★★★★★★★☆★★★★☆

一些使用上的建议：
Level 1 - 仅仅作为Map使用：采用静态数组
Level 2 - 保存定长数据，使用时也是全部遍历：采用动态数组（长度一开始就固定的话静态数组也行）
Level 3 - 保存不定长数组，需要动态增加的能力，侧重于寻找数据的速度：采用vector
Level 3 - 保存不定长数组，需要动态增加的能力，侧重于增加删除数据的速度：采用list
Level 4 - 对数据有复杂操作，即需要前后增删数据的能力，又要良好的数据访问速度：采用deque
Level 5 - 对数据中间的增删操作比较多：采用list，建议在排序的基础上，批量进行增删可以对运行效率提供最大的保证
Level 6 - 上述中找不到适合的：组合STL容器或者自己建立特殊的数据结构来实现

 

测试程序清单

>>>main.cpp<<<

0001#include <string>
0002#include <iostream>
0003#include <iomanip>
0004#include <vector>
0005#include <list>
0006#include <set>
0007#include <map>
0008#include <deque>
0009#include <algorithm>
0010#include <windows.h>
0011 
0012using namespace std;
0013 
0014inline unsigned __int64 GetTick()
0015{
0016    __asm RDTSC
0017}
0018 
0019// 定数の定義
0020const int ARRAY_SIZE = 1000 * 1000 * 1;
0021const int INSERT_NUM = 1000 * 10;
0022const int DELETE_NUM = INSERT_NUM;
0023const int READ_RANDOM_NUM = 1000 * 10;
0024const int VALUE_OFFSET = 0;
0025typedef int TARGET_TYPE;
0026typedef void (*FUNC)();
0027 
0028 
0029// グローバル変数の定義
0030__int64 g_second;
0031int g_rand_list[READ_RANDOM_NUM];
0032TARGET_TYPE g_static_array[ARRAY_SIZE];
0033TARGET_TYPE* g_dynamic_array;
0034TARGET_TYPE stub;
0035std::vector <TARGET_TYPE> g_vector;
0036std::list <TARGET_TYPE> g_list;
0037std::deque <TARGET_TYPE> g_deque;
0038 
0039 
0040// 関数定義
0041__int64 GetPerSecondTick();
0042double GetSecond(__int64 beginTick);
0043void init();
0044void uninit();
0045void start();
0046void clear();
0047void check();
0048void calctime(FUNC f, string msg);
0049void DebugOut(string str);
0050void AddOneBySelf(TARGET_TYPE& tt);
0051void SubOneBySelf(TARGET_TYPE& tt);
0052 
0053 
0054void StaticArrayCheck();
0055void DynamicArrayCheck();
0056void VectorCheck();
0057void ListCheck();
0058void DequeCheck();
0059 
0060 
0061void StaticArrayInit();
0062void DynamicArrayInit();
0063void VectorInit();
0064void ListInit();
0065void DequeInit();
0066 
0067 
0068void StaticArrayUninit();
0069void DynamicArrayUninit();
0070void VectorUninit();
0071void ListUninit();
0072void DequeUninit();
0073 
0074 
0075void StaticArrayForEach();
0076void DynamicArrayForEach();
0077void VectorForEach();
0078void ListForEach();
0079void DequeForEach();
0080 
0081 
0082void StaticArrayForEachRight();
0083void DynamicArrayForEachRight();
0084void VectorForEachRight();
0085void ListForEachRight();
0086void DequeForEachRight();
0087 
0088 
0089void StaticArrayForEachRandom();
0090void DynamicArrayForEachRandom();
0091void VectorForEachRandom();
0092void ListForEachRandom();
0093void DequeForEachRandom();
0094 
0095 
0096void VectorInsertAtBack();
0097void ListInsertAtBack();
0098void DequeInsertAtBack();
0099 
0100 
0101void VectorDeleteAtBack();
0102void ListDeleteAtBack();
0103void DequeDeleteAtBack();
0104 
0105 
0106void VectorInsertAtFront();
0107void ListInsertAtFront();
0108void DequeInsertAtFront();
0109 
0110 
0111void VectorDeleteAtFront();
0112void ListDeleteAtFront();
0113void DequeDeleteAtFront();
0114 
0115 
0116 
0117void VectorInsertAtMiddle();
0118void ListInsertAtMiddle();
0119void DequeInsertAtMiddle();
0120 
0121 
0122void VectorDeleteAtMiddle();
0123void ListDeleteAtMiddle();
0124void DequeDeleteAtMiddle();
0125 
0126 
0127void init()
0128{
0129    g_second = GetPerSecondTick();
0130    g_dynamic_array = new TARGET_TYPE[ARRAY_SIZE];
0131    srand((int)GetTick());
0132    for (int i = 0; i < READ_RANDOM_NUM; i++)
0133    {
0134        g_rand_list[i] = MulDiv(ARRAY_SIZE - 1, rand(), RAND_MAX);
0135    }
0136 
0137    calctime(StaticArrayInit, "StaticArrayInit: ");
0138    calctime(DynamicArrayInit, "DynamicArrayInit: ");
0139    calctime(VectorInit, "VectorInit: ");
0140    calctime(ListInit, "ListInit: ");
0141    calctime(DequeInit, "DequeInit: ");
0142    cout << endl;
0143}
0144 
0145void uninit()
0146{
0147    calctime(StaticArrayUninit, "StaticArrayUninit: ");
0148    calctime(DynamicArrayUninit, "DynamicArrayUninit: ");
0149    calctime(VectorUninit, "VectorUninit: ");
0150    calctime(ListUninit, "ListUninit: ");
0151    calctime(DequeUninit, "DequeUninit: ");
0152    cout << endl;
0153}
0154 
0155void check()
0156{
0157    StaticArrayCheck();
0158    DynamicArrayCheck();
0159    VectorCheck();
0160    ListCheck();
0161    DequeCheck();    
0162}
0163 
0164void start()
0165{
0166    calctime(StaticArrayForEach, "StaticArrayForEach: ");
0167    calctime(DynamicArrayForEach, "DynamicArrayForEach: ");
0168    calctime(VectorForEach, "VectorForEach: ");
0169    calctime(ListForEach, "ListForEach: ");
0170    calctime(DequeForEach, "DequeForEach: ");
0171    cout << endl;
0172    
0173    calctime(StaticArrayForEachRight, "StaticArrayForEachRight: ");
0174    calctime(DynamicArrayForEachRight, "DynamicArrayForEachRight: ");
0175    calctime(VectorForEachRight, "VectorForEachRight: ");
0176    calctime(ListForEachRight, "ListForEachRight: ");
0177    calctime(DequeForEachRight, "DequeForEachRight: ");
0178    cout << endl;
0179    
0180    calctime(StaticArrayForEachRandom, "StaticArrayForEachRandom: ");
0181    calctime(DynamicArrayForEachRandom, "DynamicArrayForEachRandom: ");
0182    calctime(VectorForEachRandom, "VectorForEachRandom: ");
0183    calctime(ListForEachRandom, "ListForEachRandom: ");
0184    calctime(DequeForEachRandom, "DequeForEachRandom: ");
0185    cout << endl;
0186    
0187    
0188    calctime(NULL, "");
0189    calctime(NULL, "");
0190    calctime(VectorInsertAtBack, "VectorInsertAtBack: ");
0191    calctime(ListInsertAtBack, "ListInsertAtBack: ");
0192    calctime(DequeInsertAtBack, "DequeInsertAtBack: ");
0193    cout << endl;
0194    
0195    
0196    calctime(NULL, "");
0197    calctime(NULL, "");
0198    calctime(VectorDeleteAtBack, "VectorDeleteAtBack: ");
0199    calctime(ListDeleteAtBack, "ListDeleteAtBack: ");
0200    calctime(DequeDeleteAtBack, "DequeDeleteAtBack: ");
0201    cout << endl;
0202    
0203    
0204    
0205    calctime(NULL, "");
0206    calctime(NULL, "");
0207    calctime(VectorInsertAtFront, "VectorInsertAtFront: ");
0208    calctime(ListInsertAtFront, "ListInsertAtFront: ");
0209    calctime(DequeInsertAtFront, "DequeInsertAtFront: ");
0210    cout << endl;
0211    
0212    
0213    calctime(NULL, "");
0214    calctime(NULL, "");
0215    calctime(VectorDeleteAtFront, "VectorDeleteAtFront: ");
0216    calctime(ListDeleteAtFront, "ListDeleteAtFront: ");
0217    calctime(DequeDeleteAtFront, "DequeDeleteAtFront: ");
0218    cout << endl;
0219    
0220    
0221    
0222    calctime(NULL, "");
0223    calctime(NULL, "");
0224    calctime(VectorInsertAtMiddle, "VectorInsertAtMiddle: ");
0225    calctime(ListInsertAtMiddle, "ListInsertAtMiddle: ");
0226    calctime(DequeInsertAtMiddle, "DequeInsertAtMiddle: ");
0227    cout << endl;
0228    
0229    
0230    calctime(NULL, "");
0231    calctime(NULL, "");
0232    calctime(VectorDeleteAtMiddle, "VectorDeleteAtMiddle: ");
0233    calctime(ListDeleteAtMiddle, "ListDeleteAtMiddle: ");
0234    calctime(DequeDeleteAtMiddle, "DequeDeleteAtMiddle: ");
0235    cout << endl;
0236}
0237 
0238 
0239void clear()
0240{
0241    delete g_dynamic_array;
0242}
0243 
0244 
0245 
0246 
0247 
0248void StaticArrayInit()
0249{
0250    for (int i = 0; i < ARRAY_SIZE; i++) g_static_array[i] = i;
0251}
0252 
0253void DynamicArrayInit()
0254{
0255    for (int i = 0; i < ARRAY_SIZE; i++) g_dynamic_array[i] = i;
0256}
0257 
0258void VectorInit()
0259{
0260    for (int i = 0; i < ARRAY_SIZE; i++) g_vector.push_back(i);
0261}
0262 
0263void ListInit()
0264{
0265    for (int i = 0; i < ARRAY_SIZE; i++) g_list.push_back(i);
0266}
0267 
0268void DequeInit()
0269{
0270    for (int i = 0; i < ARRAY_SIZE; i++) g_deque.push_back(i);
0271}
0272 
0273 
0274 
0275 
0276 
0277void StaticArrayUninit()
0278{
0279    ZeroMemory(g_static_array, ARRAY_SIZE * sizeof(TARGET_TYPE));
0280}
0281 
0282void DynamicArrayUninit()
0283{
0284    ZeroMemory(g_dynamic_array, ARRAY_SIZE * sizeof(TARGET_TYPE));
0285}
0286 
0287void VectorUninit()
0288{
0289    g_vector.clear();
0290}
0291 
0292void ListUninit()
0293{
0294    g_list.clear();
0295}
0296 
0297void DequeUninit()
0298{
0299    g_deque.clear();
0300}
0301 
0302void StaticArrayForEach()
0303{
0304    for (int i = 0; i < ARRAY_SIZE; i++) ++g_static_array[i];
0305}
0306 
0307void DynamicArrayForEach()
0308{
0309    for (int i = 0; i < ARRAY_SIZE; i++) ++g_dynamic_array[i];
0310}
0311 
0312void VectorForEach()
0313{
0314    for_each(g_vector.begin(), g_vector.end(), AddOneBySelf);
0315}
0316 
0317void ListForEach()
0318{
0319    for_each(g_list.begin(), g_list.end(), AddOneBySelf);
0320}
0321 
0322void DequeForEach()
0323{
0324    for_each(g_deque.begin(), g_deque.end(), AddOneBySelf);
0325}
0326 
0327void StaticArrayForEachRight()
0328{
0329    for (int i = ARRAY_SIZE; i > 0; i--) --g_static_array[i - 1];
0330}
0331 
0332void DynamicArrayForEachRight()
0333{
0334    for (int i = ARRAY_SIZE; i > 0; i--) --g_dynamic_array[i - 1];
0335}
0336 
0337void VectorForEachRight()
0338{
0339    for_each(g_vector.rbegin(), g_vector.rend(), SubOneBySelf);
0340}
0341 
0342void ListForEachRight()
0343{
0344    for_each(g_list.rbegin(), g_list.rend(), SubOneBySelf);
0345}
0346 
0347void DequeForEachRight()
0348{
0349    for_each(g_deque.rbegin(), g_deque.rend(), SubOneBySelf);
0350}
0351 
0352 
0353void StaticArrayForEachRandom()
0354{
0355    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_static_array[g_rand_list[i]];
0356}
0357 
0358void DynamicArrayForEachRandom()
0359{
0360    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_dynamic_array[g_rand_list[i]];
0361}
0362 
0363void VectorForEachRandom()
0364{
0365    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_vector[g_rand_list[i]];
0366}
0367 
0368void ListForEachRandom()
0369{
0370    list<TARGET_TYPE>::iterator iter;
0371 
0372    for (int i = 0; i < READ_RANDOM_NUM; i++)
0373    {
0374        iter = g_list.begin();
0375        for (int j = 0; j < g_rand_list[i]; j++) ++iter;
0376        stub = (*iter);
0377    }
0378}
0379 
0380void DequeForEachRandom()
0381{
0382    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_deque[g_rand_list[i]];
0383}
0384 
0385 
0386 
0387void StaticArrayCheck()
0388{
0389    for (int i = 0; i < ARRAY_SIZE; i++)
0390    {
0391        if (g_static_array[i] != (i + VALUE_OFFSET))
0392        {
0393            cerr << "StaticArrayCheck NG:" << i << " = " << g_static_array[i] << endl;
0394            return;
0395        }
0396    }
0397}
0398 
0399void DynamicArrayCheck()
0400{
0401    for (int i = 0; i < ARRAY_SIZE; i++)
0402    {
0403        if (g_dynamic_array[i] != (i + VALUE_OFFSET))
0404        {
0405            cerr << "DynamicArrayCheck NG:" << i << " = " << g_dynamic_array[i] << endl;
0406            return;
0407        }
0408    }
0409}
0410 
0411void VectorCheck()
0412{
0413    vector<TARGET_TYPE>::iterator iter;
0414    int i = 0;
0415 
0416    for (iter = g_vector.begin(); iter != g_vector.end(); ++iter, ++i)
0417    {
0418        if ((*iter) != (i + VALUE_OFFSET))
0419        {
0420            cerr << "VectorCheck NG:" << i << " = " << (*iter) << endl;
0421            return;
0422        }
0423    }
0424}
0425 
0426void ListCheck()
0427{
0428    list<TARGET_TYPE>::iterator iter;
0429    int i = 0;
0430 
0431    for (iter = g_list.begin(); iter != g_list.end(); ++iter, ++i)
0432    {
0433        if ((*iter) != (i + VALUE_OFFSET))
0434        {
0435            cerr << "ListCheck NG:" << i << " = " << (*iter) << endl;
0436            return;
0437        }
0438    }
0439}
0440 
0441void DequeCheck()
0442{
0443    deque<TARGET_TYPE>::iterator iter;
0444    int i = 0;
0445 
0446    for (iter = g_deque.begin(); iter != g_deque.end(); ++iter, ++i)
0447    {
0448        if ((*iter) != (i + VALUE_OFFSET))
0449        {
0450            cerr << "DequeCheck NG:" << i << " = " << (*iter) << endl;
0451            return;
0452        }
0453    }
0454}
0455 
0456 
0457 
0458void VectorInsertAtBack()
0459{
0460    for (int i = 0; i < INSERT_NUM; i++) g_vector.push_back((TARGET_TYPE)0);
0461}
0462 
0463void ListInsertAtBack()
0464{
0465    for (int i = 0; i < INSERT_NUM; i++) g_list.push_back((TARGET_TYPE)0);
0466}
0467 
0468void DequeInsertAtBack()
0469{
0470    for (int i = 0; i < INSERT_NUM; i++) g_deque.push_back((TARGET_TYPE)0);
0471}
0472 
0473void VectorDeleteAtBack()
0474{
0475    for (int i = 0; i < DELETE_NUM; i++) g_vector.pop_back();
0476}
0477 
0478void ListDeleteAtBack()
0479{
0480    for (int i = 0; i < DELETE_NUM; i++) g_list.pop_back();
0481}
0482 
0483void DequeDeleteAtBack()
0484{
0485    for (int i = 0; i < DELETE_NUM; i++) g_deque.pop_back();
0486}
0487 
0488 
0489 
0490 
0491void VectorInsertAtFront()
0492{
0493    for (int i = 0; i < INSERT_NUM; i++) g_vector.insert(g_vector.begin(), (TARGET_TYPE)0);
0494}
0495 
0496void ListInsertAtFront()
0497{
0498    for (int i = 0; i < INSERT_NUM; i++) g_list.push_front((TARGET_TYPE)0);
0499}
0500 
0501void DequeInsertAtFront()
0502{
0503    for (int i = 0; i < INSERT_NUM; i++) g_deque.push_front((TARGET_TYPE)0);
0504}
0505 
0506 
0507 
0508void VectorDeleteAtFront()
0509{
0510    for (int i = 0; i < DELETE_NUM; i++) g_vector.erase(g_vector.begin());
0511}
0512 
0513void ListDeleteAtFront()
0514{
0515    for (int i = 0; i < DELETE_NUM; i++) g_list.pop_front();
0516}
0517 
0518void DequeDeleteAtFront()
0519{
0520    for (int i = 0; i < DELETE_NUM; i++) g_deque.pop_front();
0521}
0522 
0523 
0524void VectorInsertAtMiddle()
0525{
0526    vector<TARGET_TYPE>::iterator iter;
0527    for (int i = 0; i < INSERT_NUM; i++)
0528    {
0529        iter = g_vector.begin();
0530        for (unsigned int j = 0; j < g_vector.size() / 2; j++) ++iter;
0531        g_vector.insert(iter, (TARGET_TYPE)0);
0532    }
0533}
0534 
0535void ListInsertAtMiddle()
0536{
0537    list<TARGET_TYPE>::iterator iter;
0538    for (int i = 0; i < INSERT_NUM; i++)
0539    {
0540        iter = g_list.begin();
0541        for (unsigned int j = 0; j < g_list.size() / 2; j++) ++iter;
0542        g_list.insert(iter, (TARGET_TYPE)0);
0543    }
0544}
0545 
0546void DequeInsertAtMiddle()
0547{
0548    deque<TARGET_TYPE>::iterator iter;
0549    for (int i = 0; i < INSERT_NUM; i++)
0550    {
0551        iter = g_deque.begin();
0552        for (unsigned int j = 0; j < g_deque.size() / 2; j++) ++iter;
0553        g_deque.insert(iter, (TARGET_TYPE)0);
0554    }
0555}
0556 
0557 
0558void VectorDeleteAtMiddle()
0559{
0560    vector<TARGET_TYPE>::iterator iter;
0561    for (int i = 0; i < DELETE_NUM; i++)
0562    {
0563        iter = g_vector.begin();
0564        for (unsigned int j = 0; j < g_vector.size() / 2; j++) ++iter;
0565        g_vector.erase(iter);
0566    }
0567}
0568 
0569void ListDeleteAtMiddle()
0570{
0571    list<TARGET_TYPE>::iterator iter;
0572    for (int i = 0; i < DELETE_NUM; i++)
0573    {
0574        iter = g_list.begin();
0575        for (unsigned int j = 0; j < g_list.size() / 2; j++) ++iter;
0576        g_list.erase(iter);
0577    }
0578}
0579 
0580void DequeDeleteAtMiddle()
0581{
0582    deque<TARGET_TYPE>::iterator iter;
0583    for (int i = 0; i < DELETE_NUM; i++)
0584    {
0585        iter = g_deque.begin();
0586        for (unsigned int j = 0; j < g_deque.size() / 2; j++) ++iter;
0587        g_deque.erase(iter);
0588    }
0589}
0590 
0591 
0592 
0593 
0594void calctime(FUNC f, string msg)
0595{
0596    __int64 t1;
0597    
0598    if (f != NULL)
0599    {
0600        t1 = GetTick();
0601        (*f)();
0602        // cerr << msg << GetSecond(t1) << endl;
0603        cout << GetSecond(t1) << ", ";
0604    }
0605    else
0606    {
0607        // cerr << msg << "N/A" << endl;
0608        cout << "N/A, ";
0609    }
0610}
0611 
0612__int64 GetPerSecondTick()
0613{
0614    __int64 t1;
0615    
0616    t1 = GetTick();
0617    Sleep(1000);
0618    return (GetTick() - t1);
0619}
0620 
0621double GetSecond(__int64 beginTick)
0622{
0623    return (double)(GetTick() - beginTick) / (double)g_second;
0624}
0625 
0626void AddOneBySelf(TARGET_TYPE& tt)
0627{
0628    ++tt;
0629}
0630 
0631void SubOneBySelf(TARGET_TYPE& tt)
0632{
0633    --tt;
0634}
0635 
0636void DebugOut(string str)
0637{
0638    cerr << str << endl;
0639}
0640 
0641 
0642int main(char** argv, int argc)
0643{
0644    // 初期化
0645    init();
0646 
0647    // 実行開始
0648    start();
0649    
0650    // チェック
0651    check();
0652    
0653    // 資源回収
0654    uninit();
0655    
0656    // クリア
0657    clear();
0658 
0659    return 0;
0660}
0661
adropofsnow
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STL中vector、list、deque和map的区别
07-12
STL中vector、list、deque和map的区别
vector,map,list,queue的区别详细解析
09-05
在C++标准库中，`vector`、`map`、`list`和`queue`是四种常见的容器，它们各自有着不同的特性和用途。下面将详细分析这些容器的区别以及何时选择它们。 1. **vector** - **特性**：`vector`是一种动态数组，它的...
STL容器类vector,list,deque的比较
冰雪八哥的专栏
08-09 1213
<br />STL容器类vector,list,deque的比较<br /> 作者：斑鸠<br /> 更新时间：2009/01/04<br /> 编译器版本：Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 15.00.21022.08 for 80x86<br /> C++的STL模板库中提供了3种容器类：vector,list,deque<br /> 对于这三种容器，在觉得好用的同时，经常会让我们困惑应该选择哪一种来实现我们的逻辑。<
vector、list、deque三者比较
baidui8622的博客
09-21 274
1、vector是一段连续的内存块，而deque是多个连续的内存块，list是所有数据元素分开保存，可以是任何两个元素都没有连续。 2、vector的查询性能最好，并且的末端增加数据也很好，除非它重新申请内存段，适合高效的随机存储。 3、list是一个链表，任何一个元素都可以是不连续的，但它都有两个指向上一个元素和下一个元素的指针。所以它对插入、删除元素性能是最好的，而查询性能非常差...
vector与list与deque比较
08-23 743
  vector   表示一段连续的内存区域每个元素被顺序存储在这段内存中对vector   的随机     访问比如先访问元素5   然后访问15   然后再访问7   等等效率很高因为每次访问离vector     起始处的位移都是固定的但是在任意位置而不是在vector   
对比vector、deque、list的优缺点
digitalkee的博客
06-25 2014
1、vector 连续存储结构，每个元素在内存上是连续的；支持高效的随机访问和在尾端插入/删除操作，但其他位置的插入/删除操作效率低下；相当于一个数组，但是与数组的区别为：内存空间的扩展。vector支持不指定vector大小的存储，但是数组的扩展需要程序员自己写。 vector的内存分配实现原理： STL内部实现时，首先分配一个非常大的内存空间预备进行存储，即capacity（）函数返回的大小，当超过此分配的空间时再整体重新放分配一块内存存储（VS6.0是两倍，VS2005是1.5倍），所以这给人以ve
C++各个容器比较（vector，deque，list，set，map，queue，stack）
Lyu-ming 栏目
05-10 2013
1、vector（连续的空间存储，可以使用[ ]操作符）可以快速的访问随机的元素，快速的在末尾插入元素，但是在序列中间随机的插入、删除元素要慢。而且，如果一开始分配的空间不够时，有一个重新分配更大空间的过程。     2、deque（小片的连续，小片间用链表相连，实际上内部有一个map的指针，因为知道类型，所以还是可以使用[ ]，只是速度没有vector快）快速的访问随机的元素，快速的在开始和末
STL.zip包含vector，deque和丰富的测试用例
07-06
在这个"STL.zip"压缩包中，包含了对vector和deque两种重要容器的自定义实现，以及一系列用于测试这些数据结构的用例。下面我们将深入探讨这两个容器及其相关的编程概念。 首先，`vector`是STL中最常见的动态数组，...
vector, list, map在遍历时删除符合条件的元素实现方法
08-31
在C++编程中，`vector`、`list`和`map`是三种...另外，对于`vector`，如果频繁在中间位置插入和删除元素，考虑使用`list`或`deque`可能更为合适。而对于`map`，如果只需要根据键查找和删除元素，其性能通常已经足够好。
list和vector的区别共1页.pdf.zip
10-30
以下是关于`list`和`vector`的详细比较： 1. **实现方式** - `list`：`list`是一个双向链表，每个元素都是一个节点，包含实际的数据以及指向前后节点的指针。因此，元素在链表中的插入和删除操作相对较快。 - `...
C++/C++11中std::deque的使用
热门推荐
网络资源是无限的
05-25 4万+
C++/C++11中std::deque的使用
C++ 之 deque
giturtle's blog
08-28 309
deque特性迭代器小结 特性 deque是双端队列不规则的首字母缩写，双端队列是动态大小的序列式容器，其可以向两端进行伸缩。 特定的库可以以不同的方式实现deque，但通常都是一种动态数组。不论在何种情况下，它都允许通过随机访问迭代器直接访问单个元素，可以根据需要动态的伸缩。 因此，deque提供了一些与vector相似的功能，但deque在头部和尾部进行数据插入和删除操作更加高效。 与ve...
STL容器 vector,list,deque 性能比较
木牛的博客
07-12 433
测试项目静态数组动态数组vectorlistdeque初始化★★★★★★★★★★★★★★☆★★★☆☆★★★★☆前向遍历★★★★★★★★★★★★★★☆★★★★☆★★★★☆后向遍历★★★★★★★★★★★★★★☆★★★★☆★★★★☆随机访问★★★★★★★★★★★★★★☆★☆☆☆☆★★★☆☆后端插入N/AN/A★★★★★★★★★☆★★★★★后端移除N/AN/A★★★★★★★★★☆★★★★★前端插入N/AN/A★★☆☆☆。
二、STL容器：容器总结以及vector和list
小脑斧的博客
05-16 235
1 容器简介 1.1 容器 1.1.1 顺序容器 容器 模板 特点 向量容器 vector 从后面快速插入与删除，可以直接访问任何元素。 双向列表容器 list 从任何地方快速插入与删除 双端链表容器 deque 从前面或者后面快速插入与删除，可以直接访问任何元素。 1.1.2 关联容器 容器 模板 特点 映射容器 map 一对多映射，基于关键字快速查找，不允许重复值 多重映射容器 multimap 一对多映射，基于关键字快速查找，允许重复值 集合容
STL顺序容器vector,list和deque
枕上雪
04-30 326
顺序容器是通过将指定类型的元素按照位置顺序进行存储和访问的一种容器类型. STL标准库中的顺序容器有三种:vector, list, 和deque(double ended queue双端队列,读[dɛk]) 三个容器对应的头文件:#include <vector> #include <list> #include <deque>容器的通用构造函数, 假设容器类型为vector, 保存的元素类型
STL（五）去重
叶孤城
11-03 1217
想要去除容器中的重复元素，可以用STL提供的函数std::unique。 与stl的其他删除函数类似，该函数并没有真正删除重复元素，只是移动了元素的位置，返回需要删除的逻辑位置。 除此之外，std::unique只能去除相邻的重复元素。 什么意思呢？请看下面代码： int _tmain(int argc, _TCHAR* argv[]) { using namespace std; list<int> lstInt = { 1, 2, 4, 8, 2, 2, 3, 4, 5, 8
python list的函数
dili8870的博客
04-04 580
1. list.append(obj) 在列表末尾添加新的对象 2. list.count(obj) 统计某个元素在列表中出现的次数 3. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） 4. list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 5. list.insert(index,ob...
Python 中 list 和 deque 性能对比
迪文的博客
06-29 814
list 与 deque 的性能对比如下，deque 比 list 快了将近一倍。 deque 的 appendleft() 和 popleft() 的时间复杂度为 O(1) list 的 insert(0, value) 和 pop() 的时间复杂度为 O(n) 列表追加性能好坏不定，因为它使用了realloc()。因此，往往在简单代码中列表的性能不算太差(因为 realloc 内存分配机制不需要移动数据)，而在实际应用代码中计时非常慢(因为 realloc 机制会移动所有数据)。相比之下，deque
Python | List和Deque的速度对比
I2Tran3cend的博客
08-12 488
Python | List和Deque的速度对比
c++ vector deque list
最新发布
09-02
C++中的`vector`、`deque`和`list`都是STL（Standard Template Library）中的容器类，用于存储和操作数据。 `vector`是一个动态数组，可以在数组末尾高效地添加或删除元素，也可以通过索引直接访问元素。由于连续的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值