STL容器类vector,list,deque的比较

最新推荐文章于 2024-03-05 10:57:27 发布
最新推荐文章于 2024-03-05 10:57:27 发布
阅读量960 收藏
点赞数
分类专栏： 最新学习 文章标签： vector list iterator insert delete random

STL容器类vector,list,deque的比较

 

转载自： http://ikaruga.name/Technology/ccplusplus/stlCollection.html#text1

 

 

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和希腊神话的阿吉里斯一样，
再怎么强大也是有自己的弱点的，之后的测试数据中就能看到了。

P.S.请搜索「阿吉里斯的脚后跟」来获取详细内容

 

性能竞技场

为了能更好地进行比较，我们让静态数组（程序中写死的）和
动态数组（程序中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容器或者自己建立特殊的数据结构来实现

 

#include <string>

#include <iostream>

#include <iomanip>

#include <vector>

#include <list>

#include <set>

#include <map>

#include <deque>

#include <algorithm>

#include <windows.h>

 

using namespace std;

 

inline unsigned __int64 GetTick()

{

    __asm RDTSC

}

 

// 定数の定義

const int ARRAY_SIZE = 1000 * 1000 * 1;

const int INSERT_NUM = 1000 * 10;

const int DELETE_NUM = INSERT_NUM;

const int READ_RANDOM_NUM = 1000 * 10;

const int VALUE_OFFSET = 0;

typedef int TARGET_TYPE;

typedef void (*FUNC)();

 

 

// グローバル変数の定義

__int64 g_second;

int g_rand_list[READ_RANDOM_NUM];

TARGET_TYPE g_static_array[ARRAY_SIZE];

TARGET_TYPE* g_dynamic_array;

TARGET_TYPE stub;

std::vector <TARGET_TYPE> g_vector;

std::list <TARGET_TYPE> g_list;

std::deque <TARGET_TYPE> g_deque;

 

 

// 関数定義

__int64 GetPerSecondTick();

double GetSecond(__int64 beginTick);

void init();

void uninit();

void start();

void clear();

void check();

void calctime(FUNC f, string msg);

void DebugOut(string str);

void AddOneBySelf(TARGET_TYPE& tt);

void SubOneBySelf(TARGET_TYPE& tt);

 

 

void StaticArrayCheck();

void DynamicArrayCheck();

void VectorCheck();

void ListCheck();

void DequeCheck();

 

 

void StaticArrayInit();

void DynamicArrayInit();

void VectorInit();

void ListInit();

void DequeInit();

 

 

void StaticArrayUninit();

void DynamicArrayUninit();

void VectorUninit();

void ListUninit();

void DequeUninit();

 

 

void StaticArrayForEach();

void DynamicArrayForEach();

void VectorForEach();

void ListForEach();

void DequeForEach();

 

 

void StaticArrayForEachRight();

void DynamicArrayForEachRight();

void VectorForEachRight();

void ListForEachRight();

void DequeForEachRight();

 

 

void StaticArrayForEachRandom();

void DynamicArrayForEachRandom();

void VectorForEachRandom();

void ListForEachRandom();

void DequeForEachRandom();

 

 

void VectorInsertAtBack();

void ListInsertAtBack();

void DequeInsertAtBack();

 

 

void VectorDeleteAtBack();

void ListDeleteAtBack();

void DequeDeleteAtBack();

 

 

void VectorInsertAtFront();

void ListInsertAtFront();

void DequeInsertAtFront();

 

 

void VectorDeleteAtFront();

void ListDeleteAtFront();

void DequeDeleteAtFront();

 

 

 

void VectorInsertAtMiddle();

void ListInsertAtMiddle();

void DequeInsertAtMiddle();

 

 

void VectorDeleteAtMiddle();

void ListDeleteAtMiddle();

void DequeDeleteAtMiddle();

 

 

void init()

{

    g_second = GetPerSecondTick();

    g_dynamic_array = new TARGET_TYPE[ARRAY_SIZE];

    srand((int)GetTick());

    for (int i = 0; i < READ_RANDOM_NUM; i++)

    {

        g_rand_list[i] = MulDiv(ARRAY_SIZE - 1, rand(), RAND_MAX);

    }

 

    calctime(StaticArrayInit, "StaticArrayInit: ");

    calctime(DynamicArrayInit, "DynamicArrayInit: ");

    calctime(VectorInit, "VectorInit: ");

    calctime(ListInit, "ListInit: ");

    calctime(DequeInit, "DequeInit: ");

    cout << endl;

}

 

void uninit()

{

    calctime(StaticArrayUninit, "StaticArrayUninit: ");

    calctime(DynamicArrayUninit, "DynamicArrayUninit: ");

    calctime(VectorUninit, "VectorUninit: ");

    calctime(ListUninit, "ListUninit: ");

    calctime(DequeUninit, "DequeUninit: ");

    cout << endl;

}

 

void check()

{

    StaticArrayCheck();

    DynamicArrayCheck();

    VectorCheck();

    ListCheck();

    DequeCheck();    

}

 

void start()

{

    calctime(StaticArrayForEach, "StaticArrayForEach: ");

    calctime(DynamicArrayForEach, "DynamicArrayForEach: ");

    calctime(VectorForEach, "VectorForEach: ");

    calctime(ListForEach, "ListForEach: ");

    calctime(DequeForEach, "DequeForEach: ");

    cout << endl;

    

    calctime(StaticArrayForEachRight, "StaticArrayForEachRight: ");

    calctime(DynamicArrayForEachRight, "DynamicArrayForEachRight: ");

    calctime(VectorForEachRight, "VectorForEachRight: ");

    calctime(ListForEachRight, "ListForEachRight: ");

    calctime(DequeForEachRight, "DequeForEachRight: ");

    cout << endl;

    

    calctime(StaticArrayForEachRandom, "StaticArrayForEachRandom: ");

    calctime(DynamicArrayForEachRandom, "DynamicArrayForEachRandom: ");

    calctime(VectorForEachRandom, "VectorForEachRandom: ");

    calctime(ListForEachRandom, "ListForEachRandom: ");

    calctime(DequeForEachRandom, "DequeForEachRandom: ");

    cout << endl;

    

    

    calctime(NULL, "");

    calctime(NULL, "");

    calctime(VectorInsertAtBack, "VectorInsertAtBack: ");

    calctime(ListInsertAtBack, "ListInsertAtBack: ");

    calctime(DequeInsertAtBack, "DequeInsertAtBack: ");

    cout << endl;

    

    

    calctime(NULL, "");

    calctime(NULL, "");

    calctime(VectorDeleteAtBack, "VectorDeleteAtBack: ");

    calctime(ListDeleteAtBack, "ListDeleteAtBack: ");

    calctime(DequeDeleteAtBack, "DequeDeleteAtBack: ");

    cout << endl;

    

    

    

    calctime(NULL, "");

    calctime(NULL, "");

    calctime(VectorInsertAtFront, "VectorInsertAtFront: ");

    calctime(ListInsertAtFront, "ListInsertAtFront: ");

    calctime(DequeInsertAtFront, "DequeInsertAtFront: ");

    cout << endl;

    

    

    calctime(NULL, "");

    calctime(NULL, "");

    calctime(VectorDeleteAtFront, "VectorDeleteAtFront: ");

    calctime(ListDeleteAtFront, "ListDeleteAtFront: ");

    calctime(DequeDeleteAtFront, "DequeDeleteAtFront: ");

    cout << endl;

    

    

    

    calctime(NULL, "");

    calctime(NULL, "");

    calctime(VectorInsertAtMiddle, "VectorInsertAtMiddle: ");

    calctime(ListInsertAtMiddle, "ListInsertAtMiddle: ");

    calctime(DequeInsertAtMiddle, "DequeInsertAtMiddle: ");

    cout << endl;

    

    

    calctime(NULL, "");

    calctime(NULL, "");

    calctime(VectorDeleteAtMiddle, "VectorDeleteAtMiddle: ");

    calctime(ListDeleteAtMiddle, "ListDeleteAtMiddle: ");

    calctime(DequeDeleteAtMiddle, "DequeDeleteAtMiddle: ");

    cout << endl;

}

 

 

void clear()

{

    delete g_dynamic_array;

}

 

 

 

 

 

void StaticArrayInit()

{

    for (int i = 0; i < ARRAY_SIZE; i++) g_static_array[i] = i;

}

 

void DynamicArrayInit()

{

    for (int i = 0; i < ARRAY_SIZE; i++) g_dynamic_array[i] = i;

}

 

void VectorInit()

{

    for (int i = 0; i < ARRAY_SIZE; i++) g_vector.push_back(i);

}

 

void ListInit()

{

    for (int i = 0; i < ARRAY_SIZE; i++) g_list.push_back(i);

}

 

void DequeInit()

{

    for (int i = 0; i < ARRAY_SIZE; i++) g_deque.push_back(i);

}

 

 

 

 

 

void StaticArrayUninit()

{

    ZeroMemory(g_static_array, ARRAY_SIZE * sizeof(TARGET_TYPE));

}

 

void DynamicArrayUninit()

{

    ZeroMemory(g_dynamic_array, ARRAY_SIZE * sizeof(TARGET_TYPE));

}

 

void VectorUninit()

{

    g_vector.clear();

}

 

void ListUninit()

{

    g_list.clear();

}

 

void DequeUninit()

{

    g_deque.clear();

}

 

void StaticArrayForEach()

{

    for (int i = 0; i < ARRAY_SIZE; i++) ++g_static_array[i];

}

 

void DynamicArrayForEach()

{

    for (int i = 0; i < ARRAY_SIZE; i++) ++g_dynamic_array[i];

}

 

void VectorForEach()

{

    for_each(g_vector.begin(), g_vector.end(), AddOneBySelf);

}

 

void ListForEach()

{

    for_each(g_list.begin(), g_list.end(), AddOneBySelf);

}

 

void DequeForEach()

{

    for_each(g_deque.begin(), g_deque.end(), AddOneBySelf);

}

 

void StaticArrayForEachRight()

{

    for (int i = ARRAY_SIZE; i > 0; i--) --g_static_array[i - 1];

}

 

void DynamicArrayForEachRight()

{

    for (int i = ARRAY_SIZE; i > 0; i--) --g_dynamic_array[i - 1];

}

 

void VectorForEachRight()

{

    for_each(g_vector.rbegin(), g_vector.rend(), SubOneBySelf);

}

 

void ListForEachRight()

{

    for_each(g_list.rbegin(), g_list.rend(), SubOneBySelf);

}

 

void DequeForEachRight()

{

    for_each(g_deque.rbegin(), g_deque.rend(), SubOneBySelf);

}

 

 

void StaticArrayForEachRandom()

{

    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_static_array[g_rand_list[i]];

}

 

void DynamicArrayForEachRandom()

{

    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_dynamic_array[g_rand_list[i]];

}

 

void VectorForEachRandom()

{

    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_vector[g_rand_list[i]];

}

 

void ListForEachRandom()

{

    list<TARGET_TYPE>::iterator iter;

 

    for (int i = 0; i < READ_RANDOM_NUM; i++)

    {

        iter = g_list.begin();

        for (int j = 0; j < g_rand_list[i]; j++) ++iter;

        stub = (*iter);

    }

}

 

void DequeForEachRandom()

{

    for (int i = 0; i < READ_RANDOM_NUM; i++) stub = g_deque[g_rand_list[i]];

}

 

 

 

void StaticArrayCheck()

{

    for (int i = 0; i < ARRAY_SIZE; i++)

    {

        if (g_static_array[i] != (i + VALUE_OFFSET))

        {

            cerr << "StaticArrayCheck NG:" << i << " = " << g_static_array[i] << endl;

            return;

        }

    }

}

 

void DynamicArrayCheck()

{

    for (int i = 0; i < ARRAY_SIZE; i++)

    {

        if (g_dynamic_array[i] != (i + VALUE_OFFSET))

        {

            cerr << "DynamicArrayCheck NG:" << i << " = " << g_dynamic_array[i] << endl;

            return;

        }

    }

}

 

void VectorCheck()

{

    vector<TARGET_TYPE>::iterator iter;

    int i = 0;

 

    for (iter = g_vector.begin(); iter != g_vector.end(); ++iter, ++i)

    {

        if ((*iter) != (i + VALUE_OFFSET))

        {

            cerr << "VectorCheck NG:" << i << " = " << (*iter) << endl;

            return;

        }

    }

}

 

void ListCheck()

{

    list<TARGET_TYPE>::iterator iter;

    int i = 0;

 

    for (iter = g_list.begin(); iter != g_list.end(); ++iter, ++i)

    {

        if ((*iter) != (i + VALUE_OFFSET))

        {

            cerr << "ListCheck NG:" << i << " = " << (*iter) << endl;

            return;

        }

    }

}

 

void DequeCheck()

{

    deque<TARGET_TYPE>::iterator iter;

    int i = 0;

 

    for (iter = g_deque.begin(); iter != g_deque.end(); ++iter, ++i)

    {

        if ((*iter) != (i + VALUE_OFFSET))

        {

            cerr << "DequeCheck NG:" << i << " = " << (*iter) << endl;

            return;

        }

    }

}

 

 

 

void VectorInsertAtBack()

{

    for (int i = 0; i < INSERT_NUM; i++) g_vector.push_back((TARGET_TYPE)0);

}

 

void ListInsertAtBack()

{

    for (int i = 0; i < INSERT_NUM; i++) g_list.push_back((TARGET_TYPE)0);

}

 

void DequeInsertAtBack()

{

    for (int i = 0; i < INSERT_NUM; i++) g_deque.push_back((TARGET_TYPE)0);

}

 

void VectorDeleteAtBack()

{

    for (int i = 0; i < DELETE_NUM; i++) g_vector.pop_back();

}

 

void ListDeleteAtBack()

{

    for (int i = 0; i < DELETE_NUM; i++) g_list.pop_back();

}

 

void DequeDeleteAtBack()

{

    for (int i = 0; i < DELETE_NUM; i++) g_deque.pop_back();

}

 

 

 

 

void VectorInsertAtFront()

{

    for (int i = 0; i < INSERT_NUM; i++) g_vector.insert(g_vector.begin(), (TARGET_TYPE)0);

}

 

void ListInsertAtFront()

{

    for (int i = 0; i < INSERT_NUM; i++) g_list.push_front((TARGET_TYPE)0);

}

 

void DequeInsertAtFront()

{

    for (int i = 0; i < INSERT_NUM; i++) g_deque.push_front((TARGET_TYPE)0);

}

 

 

 

void VectorDeleteAtFront()

{

    for (int i = 0; i < DELETE_NUM; i++) g_vector.erase(g_vector.begin());

}

 

void ListDeleteAtFront()

{

    for (int i = 0; i < DELETE_NUM; i++) g_list.pop_front();

}

 

void DequeDeleteAtFront()

{

    for (int i = 0; i < DELETE_NUM; i++) g_deque.pop_front();

}

 

 

void VectorInsertAtMiddle()

{

    vector<TARGET_TYPE>::iterator iter;

    for (int i = 0; i < INSERT_NUM; i++)

    {

        iter = g_vector.begin();

        for (unsigned int j = 0; j < g_vector.size() / 2; j++) ++iter;

        g_vector.insert(iter, (TARGET_TYPE)0);

    }

}

 

void ListInsertAtMiddle()

{

    list<TARGET_TYPE>::iterator iter;

    for (int i = 0; i < INSERT_NUM; i++)

    {

        iter = g_list.begin();

        for (unsigned int j = 0; j < g_list.size() / 2; j++) ++iter;

        g_list.insert(iter, (TARGET_TYPE)0);

    }

}

 

void DequeInsertAtMiddle()

{

    deque<TARGET_TYPE>::iterator iter;

    for (int i = 0; i < INSERT_NUM; i++)

    {

        iter = g_deque.begin();

        for (unsigned int j = 0; j < g_deque.size() / 2; j++) ++iter;

        g_deque.insert(iter, (TARGET_TYPE)0);

    }

}

 

 

void VectorDeleteAtMiddle()

{

    vector<TARGET_TYPE>::iterator iter;

    for (int i = 0; i < DELETE_NUM; i++)

    {

        iter = g_vector.begin();

        for (unsigned int j = 0; j < g_vector.size() / 2; j++) ++iter;

        g_vector.erase(iter);

    }

}

 

void ListDeleteAtMiddle()

{

    list<TARGET_TYPE>::iterator iter;

    for (int i = 0; i < DELETE_NUM; i++)

    {

        iter = g_list.begin();

        for (unsigned int j = 0; j < g_list.size() / 2; j++) ++iter;

        g_list.erase(iter);

    }

}

 

void DequeDeleteAtMiddle()

{

    deque<TARGET_TYPE>::iterator iter;

    for (int i = 0; i < DELETE_NUM; i++)

    {

        iter = g_deque.begin();

        for (unsigned int j = 0; j < g_deque.size() / 2; j++) ++iter;

        g_deque.erase(iter);

    }

}

 

 

 

 

void calctime(FUNC f, string msg)

{

    __int64 t1;

    

    if (f != NULL)

    {

        t1 = GetTick();

        (*f)();

        // cerr << msg << GetSecond(t1) << endl;

        cout << GetSecond(t1) << ", ";

    }

    else

    {

        // cerr << msg << "N/A" << endl;

        cout << "N/A, ";

    }

}

 

__int64 GetPerSecondTick()

{

    __int64 t1;

    

    t1 = GetTick();

    Sleep(1000);

    return (GetTick() - t1);

}

 

double GetSecond(__int64 beginTick)

{

    return (double)(GetTick() - beginTick) / (double)g_second;

}

 

void AddOneBySelf(TARGET_TYPE& tt)

{

    ++tt;

}

 

void SubOneBySelf(TARGET_TYPE& tt)

{

    --tt;

}

 

void DebugOut(string str)

{

    cerr << str << endl;

}

 

 

int main(char** argv, int argc)

{

    // 初期化

    init();

 

    // 実行開始

    start();

    

    // チェック

    check();

    

    // 資源回収

    uninit();

    

    // クリア

    clear();

 

    return 0;

}

 

wangxfvc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++:STL之vector,deque对比
xh19910615的专栏
01-09 618
之所以专门把STL中的这两个拿出来说一说，是因为vector和deque都是支持随机访问的，其支持的迭代器类型都为随机访问，而不像map,set,list等都是支持双向迭代器的。 vector,deuqe之对比： 1：随机访问速度：vector > deque。 2；deque性能损失比vector高几个数量级：因为deque首次插入一个元素时，会默认动态分配512字节空间，当这512字
【STL】容器（一）——顺序容器vector、list、deque（初级简单了解）
IT_Mitchell的博客
08-31 480
目录 一、vector （一）对于vector容器的插入删除以及访问的研究： （二）vector的扩容机制 （三）优缺点 二、list （一）对于list插入删除以及访问的研究： （二）list的优缺点 三、deque （一）对于deque容器的插入删除操作以及访问的研究 （二）deque的扩容机制 （三）优缺点 四、vector和deque的区别 一、vector V...
vector、list、deque三者比较
baidui8622的博客
09-21 280
1、vector是一段连续的内存块，而deque是多个连续的内存块，list是所有数据元素分开保存，可以是任何两个元素都没有连续。 2、vector的查询性能最好，并且的末端增加数据也很好，除非它重新申请内存段，适合高效的随机存储。 3、list是一个链表，任何一个元素都可以是不连续的，但它都有两个指向上一个元素和下一个元素的指针。所以它对插入、删除元素性能是最好的，而查询性能非常差...
vector与list与deque比较
08-23 753
  vector   表示一段连续的内存区域每个元素被顺序存储在这段内存中对vector   的随机     访问比如先访问元素5   然后访问15   然后再访问7   等等效率很高因为每次访问离vector     起始处的位移都是固定的但是在任意位置而不是在vector   
对比vector、deque、list的优缺点
digitalkee的博客
06-25 2078
1、vector 连续存储结构，每个元素在内存上是连续的；支持高效的随机访问和在尾端插入/删除操作，但其他位置的插入/删除操作效率低下；相当于一个数组，但是与数组的区别为：内存空间的扩展。vector支持不指定vector大小的存储，但是数组的扩展需要程序员自己写。 vector的内存分配实现原理： STL内部实现时，首先分配一个非常大的内存空间预备进行存储，即capacity（）函数返回的大小，当超过此分配的空间时再整体重新放分配一块内存存储（VS6.0是两倍，VS2005是1.5倍），所以这给人以ve
vector,list deque三种容器对比
qq_53737964的博客
01-20 192
一、vector与list对比 vector: 随机访问快，即下标运算 尾添加，不申请空间的情况下，速度很快 不支持，快速插入和删除，比较慢 list: 随机访问慢 支持快速插入和删除 二、内存对比 vector： 连续空间 list： 不连续空间 deque: 段连续空间 三、功能对比 vector: 随机位置插入删除效率很低 随机访问效率高（下标运算） 头添加缓慢不推荐，支持尾添加 list： 随机位置插入/删除效率高 随机访问效率慢 支持头添
C++各个容器比较（vector，deque，list，set，map，queue，stack）
Lyu-ming 栏目
05-10 2085
1、vector（连续的空间存储，可以使用[ ]操作符）可以快速的访问随机的元素，快速的在末尾插入元素，但是在序列中间随机的插入、删除元素要慢。而且，如果一开始分配的空间不够时，有一个重新分配更大空间的过程。     2、deque（小片的连续，小片间用链表相连，实际上内部有一个map的指针，因为知道类型，所以还是可以使用[ ]，只是速度没有vector快）快速的访问随机的元素，快速的在开始和末
C++/C++11中std::deque的使用
热门推荐
网络资源是无限的
05-25 4万+
C++/C++11中std::deque的使用
C++ 之 deque
giturtle's blog
08-28 343
deque特性迭代器小结 特性 deque是双端队列不规则的首字母缩写，双端队列是动态大小的序列式容器，其可以向两端进行伸缩。 特定的库可以以不同的方式实现deque，但通常都是一种动态数组。不论在何种情况下，它都允许通过随机访问迭代器直接访问单个元素，可以根据需要动态的伸缩。 因此，deque提供了一些与vector相似的功能，但deque在头部和尾部进行数据插入和删除操作更加高效。 与ve...
突破编程_C++_STL教程（ deque 的实战应用）
最新发布
突破编程
03-05 1155
C++ STL编程： std::deque 的实战应用
C++STL之vecot、list、deque的排序插入访问效率
zidian666的博客
01-20 681
低数据量的参考价值不高，其余数据仅供参考，测试代码在末尾 排序 第一次测试 第二次测试 STL类型 数据量 时间 STL类型 数据量 时间 vector [10] 0.002000 ms vector [10] 0.001200 ms deque [10] 0.001000 ms deque [10] 0.001200 ms list [10] 0.006100 m...
C++中的队列(queue)和优先队列(priority_queue)总结
Rosun
11-30 2373
1.queue introduction队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受
c++基础组件性能对比测试（1）双向队列std::deque和libuv队列
robinfoxnan的专栏
06-17 627
duibi int main() { Student * students = new Student[10000]; Student * it = students; for (int i = 0; i < 10000; i++) { it = students + i; it->age = i + 1; it->name = "robin"; } Timer timer1; timer1.start(); // 在UV插入信息 QUEUE ...
C++ list 与 deque 比较
GIS探索之路
02-20 1587
题目描述：dota2-senate #include <string> #include <list> using namespace std; class Solution { public: string predictPartyVictory(string senate) { int cnt = 0; list<int> R; list&lt...
STL顺序容器vector,list和deque
枕上雪
04-30 339
顺序容器是通过将指定类型的元素按照位置顺序进行存储和访问的一种容器类型. STL标准库中的顺序容器有三种:vector, list, 和deque(double ended queue双端队列,读[dɛk]) 三个容器对应的头文件:#include <vector> #include <list> #include <deque>容器的通用构造函数, 假设容器类型为vector, 保存的元素类型
STL（五）去重
叶孤城
11-03 1251
想要去除容器中的重复元素，可以用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 609
1. list.append(obj) 在列表末尾添加新的对象 2. list.count(obj) 统计某个元素在列表中出现的次数 3. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） 4. list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 5. list.insert(index,ob...
Python | List和Deque的速度对比
I2Tran3cend的博客
08-12 501
Python | List和Deque的速度对比
C++ STL实战教程：Vector、Deque、List与Set等
"STL范例大全，涵盖C++中的各种STL容器，如Vector、Deque、List、Set等，提供实例教程，包含类和结构体的使用" 在C++编程中，Standard Template Library (STL) 是一个重要的库，它提供了高效的数据结构和算法。这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值