精华内容
下载资源
问答
  • STL 容器

    2011-10-05 21:57:20
    STL Containers,STL容器,他用来存储一组对象,在存储对象上,比较灵活。容器管理着这些元素的存储,并且提供了一些方法直接的去访问或者提供iterators(reference objects with similar properties to pointers).
    STL Containers,STL容器,他用来存储一组对象,在存储对象上,比较灵活。
    容器管理着这些元素的存储,并且提供了一些方法直接的去访问或者提供iterators(reference objects with similar properties to pointers).
    我们经常使用的重写容器的一些class有如下:
    动态数组 (vector),队列(queue), 堆 (stack), 栈 (priority_queue), 链表(list), 树 (set), map(map)...
    这些容器内部都有有些方法,在实际应用中,我们应该根据这些容器的内部方法的使用效率来决定。比如插入删除,链表等高效一些
    stack, queuepriority_queue 被实现为容器的适配器。
    容器适配器不完全是容器类,对依赖的一些容器类,提供了一些特殊结构,比如用deque or list去处理。其他的容器类被封装成气元素方法的一些方法使用
    容器类 顺序容器 :

    Sequence containers:

    vector

    Vector (class template )

     

    deque

    Double ended queue (class template )

     

    list

    List (class template )

    Container adaptors:

    stack

    LIFO stack (class template )

     

    queue

    FIFO queue (class template )

     

    priority_queue

    Priority queue (class template)

    Associative containers:

    set

    Set (class template )

     

    multiset

    Multiple-key set (class template)

     

    map

    Map (class template )

     

    multimap

    Multiple-key map (class template )

     

    bitset

    Bitset (class template)

     

    Member map

    This is a comparison chart with thedifferent member functions present on each of the different containers:

     

    Sequence containers

    Associative containers

    Headers

    <vector>

    <deque>

    <list>

    <set>

    <map>

    <bitset>

    Members

    complex

    vector

    deque

    list

    set

    multiset

    map

    multimap

    bitset

    constructor

    *

    constructor

    constructor

    constructor

    constructor

    constructor

    constructor

    constructor

    constructor

    destructor

    O(n)

    destructor

    destructor

    destructor

    destructor

    destructor

    destructor

    destructor

    operator=

    O(n)

    operator=

    operator=

    operator=

    operator=

    operator=

    operator=

    operator=

    operators

    iterators

    begin

    O(1)

    begin

    begin

    begin

    begin

    begin

    begin

    begin

    end

    O(1)

    end

    end

    end

    end

    end

    end

    end

    rbegin

    O(1)

    rbegin

    rbegin

    rbegin

    rbegin

    rbegin

    rbegin

    rbegin

    rend

    O(1)

    rend

    rend

    rend

    rend

    rend

    rend

    rend

    capacity

    size

    *

    size

    size

    size

    size

    size

    size

    size

    size

    max_size

    *

    max_size

    max_size

    max_size

    max_size

    max_size

    max_size

    max_size

    empty

    O(1)

    empty

    empty

    empty

    empty

    empty

    empty

    empty

    resize

    O(n)

    resize

    resize

    resize

    element access

    front

    O(1)

    front

    front

    front

    back

    O(1)

    back

    back

    back

    operator[]

    *

    operator[]

    operator[]

    operator[]

    operator[]

    at

    O(1)

    at

    at

    modifiers

    assign

    O(n)

    assign

    assign

    assign

    insert

    *

    insert

    insert

    insert

    insert

    insert

    insert

    insert

    erase

    *

    erase

    erase

    erase

    erase

    erase

    erase

    erase

    swap

    O(1)

    swap

    swap

    swap

    swap

    swap

    swap

    swap

    clear

    O(n)

    clear

    clear

    clear

    clear

    clear

    clear

    clear

    push_front

    O(1)

    push_front

    push_front

    pop_front

    O(1)

    pop_front

    pop_front

    push_back

    O(1)

    push_back

    push_back

    push_back

    pop_back

    O(1)

    pop_back

    pop_back

    pop_back

    observers

    key_comp

    O(1)

    key_comp

    key_comp

    key_comp

    key_comp

    value_comp

    O(1)

    value_comp

    value_comp

    value_comp

    value_comp

    operations

    find

    O(log n)

    find

    find

    find

    find

    count

    O(log n)

    count

    count

    count

    count

    count

    lower_bound

    O(log n)

    lower_bound

    lower_bound

    lower_bound

    lower_bound

    upper_bound

    O(log n)

    upper_bound

    upper_bound

    upper_bound

    upper_bound

    equal_range

    O(log n)

    equal_range

    equal_range

    equal_range

    equal_range

    unique members

    capacity reserve

    splice remove remove_if unique merge sort reverse

    set reset flip to_ulong to_string test any none

    Amortized complexity shown. Legend: O(1) constant < O(log n)logarithmic < O(n) linear; *=depends on container Container adaptors:

    Container Adaptors

    Headers

    <stack>

    <queue>

    Members

    stack

    queue

    priority_queue

    constructor

    *

    constructor

    constructor

    constructor

    capacity

    size

    O(1)

    size

    size

    size

    empty

    O(1)

    empty

    empty

    empty

    element access

    front

    O(1)

    front

    back

    O(1)

    back

    top

    O(1)

    top

    top

    modifiers

    push

    O(1)

    push

    push

    push

    pop

    O(1)

    pop

    pop

    pop

    展开全文
  • STL容器

    千次阅读 2016-06-01 12:31:43
    什么是容器 首先,我们必须理解一下什么是容器,在C++ 中容器被定义为:在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器。很简单,容器就是保存其它对象的对象...

    什么是容器

    首先,我们必须理解一下什么是容器,在C++ 中容器被定义为:在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器。很简单,容器就是保存其它对象的对象,当然这是一个朴素的理解,这种“对象”还包含了一系列处理“其它对象”的方法,因为这些方法在程序的设计上会经常被用到,所以容器也体现了一个好处,就是“容器类是一种对特定代码重用问题的良好的解决方案”。

    容器还有另一个特点是容器可以自行扩展。在解决问题时我们常常不知道我们需要存储多少个对象,也就是说我们不知道应该创建多大的内存空间来保存我们的对象。显然,数组在这一方面也力不从心。容器的优势就在这里,它不需要你预先告诉它你要存储多少对象,只要你创建一个容器对象,并合理的调用它所提供的方法,所有的处理细节将由容器来自身完成。它可以为你申请内存或释放内存,并且用最优的算法来执行您的命令。

    容器是随着面向对象语言的诞生而提出的,容器类在面向对象语言中特别重要,甚至它被认为是早期面向对象语言的基础。在现在几乎所有的面向对象的语言中也都伴随着一个容器集,在C++ 中,就是标准模板库(STL )。

    和其它语言不一样,C++ 中处理容器是采用基于模板的方式。标准C++ 库中的容器提供了多种数据结构,这些数据结构可以与标准算法一起很好的工作,这为我们的软件开发提供了良好的支持!

    通用容器的分类

    STL 对定义的通用容器分三类:顺序性容器、关联式容器和容器适配器。

    顺序性容器 是一种各元素之间有顺序关系的线性表,是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置,除非用删除或插入的操作改变这个位置。这个位置和元素本身无关,而和操作的时间和地点有关,顺序性容器不会根据元素的特点排序而是直接保存了元素操作时的逻辑顺序。比如我们一次性对一个顺序性容器追加三个元素,这三个元素在容器中的相对位置和追加时的逻辑次序是一致的。

    关联式容器 和顺序性容器不一样,关联式容器是非线性的树结构,更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系,也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。但是关联式容器提供了另一种根据元素特点排序的功能,这样迭代器就能根据元素的特点“顺序地”获取元素。

    关联式容器另一个显著的特点是它是以键值的方式来保存数据,就是说它能把关键字和值关联起来保存,而顺序性容器只能保存一种(可以认为它只保存关键字,也可以认为它只保存值)。这在下面具体的容器类中可以说明这一点。

    容器适配器 是一个比较抽象的概念, C++的解释是:适配器是使一事物的行为类似于另一事物的行为的一种机制。容器适配器是让一种已存在的容器类型采用另一种不同的抽象类型的工作方式来实现的一种机制。其实仅是发生了接口转换。那么你可以把它理解为容器的容器,它实质还是一个容器,只是他不依赖于具体的标准容器类型,可以理解是容器的模版。或者把它理解为容器的接口,而适配器具体采用哪种容器类型去实现,在定义适配器的时候可以由你决定。

    下表列出STL 定义的三类容器所包含的具体容器类:

    标准容器类

    特点

    顺序性容器

    vector

    从后面快速的插入与删除,直接访问任何元素

    deque

    从前面或后面快速的插入与删除,直接访问任何元素

    list

    双链表,从任何地方快速插入与删除

    关联容器

    set

    快速查找,不允许重复值

    multiset

    快速查找,允许重复值

    map

    一对多映射,基于关键字快速查找,不允许重复值

    multimap

    一对多映射,基于关键字快速查找,允许重复值

    容器适配器

    stack

    后进先出

    queue

    先进先出

    priority_queue

    最高优先级元素总是第一个出列


    顺序性容器

     

    向量 vector :  

    是一个线性顺序结构。相当于数组,但其大小可以不预先指定,并且自动扩展。它可以像数组一样被操作,由于它的特性我们完全可以将vector 看作动态数组。
    在创建一个vector 后,它会自动在内存中分配一块连续的内存空间进行数据存储,初始的空间大小可以预先指定也可以由vector 默认指定,这个大小即capacity ()函数的返回值。当存储的数据超过分配的空间时vector 会重新分配一块内存块,但这样的分配是很耗时的,在重新分配空间时它会做这样的动作:

    首先,vector 会申请一块更大的内存块;

    然后,将原来的数据拷贝到新的内存块中;

    其次,销毁掉原内存块中的对象(调用对象的析构函数);

    最后,将原来的内存空间释放掉。

    如果vector 保存的数据量很大时,这样的操作一定会导致糟糕的性能(这也是vector 被设计成比较容易拷贝的值类型的原因)。所以说vector 不是在什么情况下性能都好,只有在预先知道它大小的情况下vector 的性能才是最优的。

    vector 的特点:
    (1) 指定一块如同数组一样的连续存储,但空间可以动态扩展。即它可以像数组一样操作,并且可以进行动态操作。通常体现在push_back() pop_back() 。
    (2) 随机访问方便,它像数组一样被访问,即支持[ ] 操作符和vector.at()
    (3) 节省空间,因为它是连续存储,在存储数据的区域都是没有被浪费的,但是要明确一点vector 大多情况下并不是满存的,在未存储的区域实际是浪费的。

    (4) 在内部进行插入、删除操作效率非常低,这样的操作基本上是被禁止的。Vector 被设计成只能在后端进行追加和删除操作,其原因是vector 内部的实现是按照顺序表的原理。
    (5) 只能在vector 的最后进行push 和pop ,不能在vector 的头进行push 和pop 。
    (6) 当动态添加的数据超过vector 默认分配的大小时要进行内存的重新分配、拷贝与释放,这个操作非常消耗性能。 所以要vector 达到最优的性能,最好在创建vector 时就指定其空间大小。

    双向链表list

    是一个线性链表结构,它的数据由若干个节点构成,每一个节点都包括一个信息块(即实际存储的数据)、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩,这是因为它存储在非连续的内存空间中,并且由指针将有序的元素链接起来。

    由于其结构的原因,list 随机检索的性能非常的不好,因为它不像vector 那样直接找到元素的地址,而是要从头一个一个的顺序查找,这样目标元素越靠后,它的检索时间就越长。检索时间与目标元素的位置成正比。

    虽然随机检索的速度不够快,但是它可以迅速地在任何节点进行插入和删除操作。因为list 的每个节点保存着它在链表中的位置,插入或删除一个元素仅对最多三个元素有所影响,不像vector 会对操作点之后的所有元素的存储地址都有所影响,这一点是vector 不可比拟的。

    list 的特点:
    (1) 不使用连续的内存空间这样可以随意地进行动态操作;
    (2) 可以在内部任何位置快速地插入或删除,当然也可以在两端进行push 和pop 。
    (3) 不能进行内部的随机访问,即不支持[ ] 操作符和vector.at() ;
    (4) 相对于verctor 占用更多的内存。

    双端队列deque 
    是一种优化了的、对序列两端元素进行添加和删除操作的基本序列容器。它允许较为快速地随机访问,但它不像vector 把所有的对象保存在一块连续的内存块,而是采用多个连续的存储块,并且在一个映射结构中保存对这些块及其顺序的跟踪。向deque 两端添加或删除元素的开销很小。它不需要重新分配空间,所以向末端增加元素比vector 更有效。

    实际上,deque 是对vector 和list 优缺点的结合,它是处于两者之间的一种容器。

    deque 的特点:
    (1) 随机访问方便,即支持[ ] 操作符和vector.at() ,但性能没有vector 好;
    (2) 可以在内部进行插入和删除操作,但性能不及list ;
    (3) 可以在两端进行push 、pop ;

    三者的比较

    下图描述了vector 、list 、deque 在内存结构上的特点:


     

    vector 是一段连续的内存块,而deque 是多个连续的内存块, list 是所有数据元素分开保存,可以是任何两个元素没有连续。

    vector 的查询性能最好,并且在末端增加数据也很好,除非它重新申请内存段;适合高效地随机存储。

    list 是一个链表,任何一个元素都可以是不连续的,但它都有两个指向上一元素和下一元素的指针。所以它对插入、删除元素性能是最好的,而查询性能非常差;适合 大量地插入和删除操作而不关心随机存取的需求。

    deque 是介于两者之间,它兼顾了数组和链表的优点,它是分块的链表和多个数组的联合。所以它有被list 好的查询性能,有被vector 好的插入、删除性能。 如果你需要随即存取又关心两端数据的插入和删除,那么deque 是最佳之选。

    关联容器

    set, multiset, map, multimap 是一种非线性的树结构,具体的说采用的是一种比较高效的特殊的平衡检索二叉树—— 红黑树结构。(至于什么是红黑树,我也不太理解,只能理解到它是一种二叉树结构)

    因为关联容器的这四种容器类都使用同一原理,所以他们核心的算法是一致的,但是它们在应用上又有一些差别,先描述一下它们之间的差别。

    set ,又称集合,实际上就是一组元素的集合,但其中所包含的元素的值是唯一的,且是按一定顺序排列的,集合中的每个元素被称作集合中的实例。因为其内部是通过链表的方式来组织,所以在插入的时候比vector 快,但在查找和末尾添加上被vector 慢。

    multiset ,是多重集合,其实现方式和set 是相似的,只是它不要求集合中的元素是唯一的,也就是说集合中的同一个元素可以出现多次。

    map ,提供一种“键- 值”关系的一对一的数据存储能力。其“键”在容器中不可重复,且按一定顺序排列(其实我们可以将set 也看成是一种键- 值关系的存储,只是它只有键没有值。它是map 的一种特殊形式)。由于其是按链表的方式存储,它也继承了链表的优缺点。

    multimap , 和map 的原理基本相似,它允许“键”在容器中可以不唯一。

    关联容器的特点是明显的,相对于顺序容器,有以下几个主要特点:

    1, 其内部实现是采用非线性的二叉树结构,具体的说是红黑树的结构原理实现的;

    2, set 和map 保证了元素的唯一性,mulset 和mulmap 扩展了这一属性,可以允许元素不唯一;

    3, 元素是有序的集合,默认在插入的时候按升序排列。

    基于以上特点,

    1, 关联容器对元素的插入和删除操作比vector 要快,因为vector 是顺序存储,而关联容器是链式存储;比list 要慢,是因为即使它们同是链式结构,但list 是线性的,而关联容器是二叉树结构,其改变一个元素涉及到其它元素的变动比list 要多,并且它是排序的,每次插入和删除都需要对元素重新排序;

    2, 关联容器对元素的检索操作比vector 慢,但是比list 要快很多。vector 是顺序的连续存储,当然是比不上的,但相对链式的list 要快很多是因为list 是逐个搜索,它搜索的时间是跟容器的大小成正比,而关联容器 查找的复杂度基本是Log(N) ,比如如果有1000 个记录,最多查找10 次,1,000,000 个记录,最多查找20 次。容器越大,关联容器相对list 的优越性就越能体现;

    3, 在使用上set 区别于vector,deque,list 的最大特点就是set 是内部排序的,这在查询上虽然逊色于vector ,但是却大大的强于list 。

    4, 在使用上map 的功能是不可取代的,它保存了“键- 值”关系的数据,而这种键值关系采用了类数组的方式。数组是用数字类型的下标来索引元素的位置,而map 是用字符型关键字来索引元素的位置。在使用上map 也提供了一种类数组操作的方式,即它可以通过下标来检索数据,这是其他容器做不到的,当然也包括set 。(STL 中只有vector 和map 可以通过类数组的方式操作元素,即如同ele[1] 方式)

    容器适配器

    STL 中包含三种适配器:栈stack 、队列queue 和优先级priority_queue 。

    适配器是容器的接口,它本身不能直接保存元素,它保存元素的机制是调用另一种顺序容器去实现,即可以把适配器看作“它保存一个容器,这个容器再保存所有元素”。

    STL 中提供的三种适配器可以由某一种顺序容器去实现。默认下stack 和queue 基于deque 容器实现,priority_queue 则基于vector 容器实现。当然在创建一个适配器时也可以指定具体的实现容器,创建适配器时在第二个参数上指定具体的顺序容器可以覆盖适配器的默认实现。

    由于适配器的特点,一个适配器不是可以由任一个顺序容器都可以实现的。

    栈stack 的特点是后进先出,所以它关联的基本容器可以是任意一种顺序容器,因为这些容器类型结构都可以提供栈的操作有求,它们都提供了push_back 、pop_back 和back 操作;

    队列queue 的特点是先进先出,适配器要求其关联的基础容器必须提供pop_front 操作,因此其不能建立在vector 容器上;

    优先级队列priority_queue 适配器要求提供随机访问功能,因此不能建立在list 容器上。

    展开全文
  • C++STL容器总结

    万次阅读 多人点赞 2019-02-27 16:34:46
    持续更新中!!! 各大容器的特点: ...1.可以用下标访问的容器有(既可以插入也可以赋值):vector、deque、map; 特别要注意一下,vector和deque如果没有预先指定大小,是不能用下标法插入元素的...

    各大容器的特点:

    1.可以用下标访问的容器有(既可以插入也可以赋值):vector、deque、map;

    特别要注意一下,vector和deque如果没有预先指定大小,是不能用下标法插入元素的!

    2. 序列式容器才可以在容器初始化的时候制定大小,关联式容器不行;

    3.注意,关联容器的迭代器不支持it+n操作,仅支持it++操作。

                                                              序列式容器:

    一、vector

    当需要使用数组的情况下,可以考虑使用vector

     1.特点:

     (1) 一个动态分配的数组(当数组空间内存不足时,都会执行: 分配新空间-复制元素-释放原空间);

     (2) 当删除元素时,不会释放限制的空间,所以向量容器的容量(capacity)大于向量容器的大小(size);

     (3) 对于删除或插入操作,执行效率不高,越靠后插入或删除执行效率越高;

     (4) 高效的随机访问的容器。

     

     2.创建vecotr对象:

     (1) vector<int> v1;

     (2) vector<int> v2(10);  

     

     3.基本操作:

     v.capacity();  //容器容量

     v.size();      //容器大小

     v.at(int idx); //用法和[]运算符相同

     v.push_back(); //尾部插入

     v.pop_back();  //尾部删除

     v.front();     //获取头部元素

     v.back();      //获取尾部元素

     v.begin();     //头元素的迭代器

     v.end();       //尾部元素的迭代器

     v.insert(pos,elem); //pos是vector的插入元素的位置

     v.insert(pos, n, elem) //在位置pos上插入n个元素elem

     v.insert(pos, begin, end);

     v.erase(pos);   //移除pos位置上的元素,返回下一个数据的位置

     v.erase(begin, end); //移除[begin, end)区间的数据,返回下一个元素的位置

     

     reverse(pos1, pos2); //将vector中的pos1~pos2的元素逆序存储

     

     

     

    二分查找

    #include<iostream>

    #include<algorithm>

    #include<vector>

    #include<deque>

    #include<map>

    #include<cstring>

    using namespace std;

    int  main()

    {

        vector<int> v(10);

        int num;

        vector<int>::iterator beg = v.begin();

        vector<int>::iterator end = v.end();

        vector<int>::iterator mid = v.begin() + (end - beg) / 2;

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

        {

             v[i] = i;

        }

        cin >> num;

        sort(v.begin(), v.end());

        while (*mid != num &&  beg <= end)

        {

             if (num < *mid)

             {

                 end = mid;

             }

             else

             {

                 beg = mid + 1;

             }

             mid = beg + (end - beg) / 2;

        }

        if (*mid == num)

        {

             cout << "Find" << endl;

        }

        else

        {

             cout << "Not Find" << endl;

        }

        return 0;

    }

     二、deque

    1.特点:

    (1) deque(double-ended queue 双端队列);

    (2) 具有分段数组、索引数组, 分段数组是存储数据的,索引数组是存储每段数组的首地址;

    (3) 向两端插入元素效率较高!

        (若向两端插入元素,如果两端的分段数组未满,既可插入;如果两端的分段数组已满,

        则创建新的分段函数,并把分段数组的首地址存储到deque容器中即可)。

        中间插入元素效率较低!

     

    2. 创建deque对象

    (1) deque<int> d1;

    (2) deque<int> d2(10);

     

    3. 基本操作:

    (1) 元素访问:

    d[i];

    d.at[i];

    d.front();

    d.back();

    d.begin();

    d.end();

     

    (2) 添加元素:

    d.push_back();

    d.push_front();

    d.insert(pos,elem); //pos是vector的插入元素的位置

    d.insert(pos, n, elem) //在位置pos上插入n个元素elem

    d.insert(pos, begin, end);

     

    (3) 删除元素:

    d.pop_back();

    d.pop_front();

    d.erase(pos);   //移除pos位置上的元素,返回下一个数据的位置

    d.erase(begin, end); //移除[begin, end)区间的数据,返回下一个元素的位置

     

    三、list

    1. 特点:

    (1) 双向链表

     

    2.创建对象:

    list<int> L1;

    list<int> L2(10);

     

    3.基本操作:

    (1) 元素访问:

    lt.front();

    lt.back();

    lt.begin();

    lt.end();

     

    (2) 添加元素:

    lt.push_back();

    lt.push_front();

    lt.insert(pos, elem);

    lt.insert(pos, n , elem);

    lt.insert(pos, begin, end);

     

    lt.pop_back();

    lt.pop_front();

    lt.erase(begin, end);

    lt.erase(elem);

     

    (3)sort()函数、merge()函数、splice()函数:

    sort()函数就是对list中的元素进行排序;

    merge()函数的功能是:将两个容器合并,合并成功后会按从小到大的顺序排列;

    比如:lt1.merge(lt2); lt1容器中的元素全都合并到容器lt2中。

    splice()函数的功能是:可以指定合并位置,但是不能自动排序!

     

    这些函数用到的次数较少,要用时再加深印象!!!

     

                                                                关联式容器:

    1. 特点:

    (1) 关联式容器都是有序的,升序排列,自动排序;

    (2) 实现的是一个平衡二叉树,每个元素都有一个父节点和两个子节点,

    左子树的所有元素都比自己小,右子树的所有元素都比自己大;

     

    四、set/multiset

    1. 特点:

    构造set集合的主要目的是为了快速检索,去重与排序

    (1) set存储的是一组无重复的元素,而multiset允许存储有重复的元素;

    (2) 如果要修改某一个元素值,必须先删除原有的元素,再插入新的元素。

     

    2.创建对象:

    set<T> s;

    set<T, op(比较结构体)> s;     //op为排序规则,默认规则是less<T>(升序排列),或者是greater<T>(降序规则)。

    函数对象:

    class Sum

    {

    public:

        int operator()(int a, int b){return a+b;}

    };

     

    Sum sum;  //利用了()运算符的重载

     

    3. 基本操作:

    s.size();      //元素的数目

    s.max_size();  //可容纳的最大元素的数量

    s.empty();     //判断容器是否为空

    s.find(elem);  //返回值是迭代器类型

    s.count(elem); //elem的个数,要么是1,要么是0,multiset可以大于一

    s.begin();

    s.end();

    s.rbegin();

    s.rend();

    s.insert(elem);

    s.insert(pos, elem);

    s.insert(begin, end);

    s.erase(pos);

    s.erase(begin,end);

    s.erase(elem);

    s.clear();//清除a中所有元素;

     

    pair类模板

    1. 主要作用是将两个数据组成一个数据,用来表示一个二元组或一个元素对,

    两个数据可以是同一个类型也可以是不同的类型。

    当需要将两个元素组合在一起时,可以选择构造pair对象,

    set的insert返回值为一个pair<set<int>::iterator,bool>。bool标志着插入是否成功,而iterator代表插入的位置,若该键值已经在set中,则iterator表示已存在的该键值在set中的位置。

    如:set<int> a;

               a.insert(1);

               a.insert(2);

               a.insert(2);//重复的元素不会被插入;

     

    注意一下:make_pair()函数内调用的仍然是pair构造函数

     

    set中的erase()操作是不进行任何的错误检查的,比如定位器的是否合法等等,所以用的时候自己一定要注意。

    创建pair对象:

    pair<int, float> p1;   //调用构造函数来创建pair对象

    make_pair(1,1.2);      //调用make_pair()函数来创建pair对象

     

    pair对象的使用:

    pair<int, float> p1(1, 1.2);

    cout<< p1.first << endl;

    cout<< p1.second << endl;

     

    顺序遍历:

    set<int> a;

    set<int>::iterator it=a.begin();

    for(;it!=a.end();it++)

        cout<<*it<<endl;

     

    反序遍历:

    set<int> a;

    set<int>::reverse_iterator rit=a.rbegin();

    for(;rit!=a.rend();rit++)

    cout<<*rit<<endl;

     

    find(key_value);//如果找到查找的键值,则返回该键值的迭代器位置,否则返回集合最后一个元素后一个位置的迭代器,即end();

    如:int b[]={1,2,3,4,5};     set<int> a(b,b+5);

            set<int>::iterator it;

            it=a.find(3);

            if(it!=a.end())  cout<<*it<<endl;

            else cout<<“该元素不存在”<<endl;

            it=a.find(10);

            if(it!=a.end())  cout<<*it<<endl;

            else cout<<“该元素不存在”<<endl;

     

    定义比较函数

         set容器在判定已有元素a和新插入元素b是否相等时,是这么做的:

    (1)将a作为左操作数,b作为右操作数,调用比较函数,并返回比较值 ;

    (2)将b作为左操作数,a作为右操作数,再调用一次比较函数,并返回比较值。

         也就是说,假设有比较函数f(x,y),要对已有元素a和新插入元素b进行比较时,会先进行f(a,b)操作,再进行f(b,a)操作,然后返回两个bool值。

    如果1、2两步的返回值都是false,则认为a、b是相等的,则b不会被插入set容器中;

    如果1返回true而2返回false,那么认为b要排在a的后面,反之则b要排在a的前面;

    如果1、2两步的返回值都是true,则可能发生未知行为。

     

    (1)自定义比较结构体;

    首先,定义比较结构体

    struct myComp

    {

         bool operator() (const 类型 &a, const 类型 &b)//重载“()”操作符

              {

                     ……

                    return  ……;

              }

    };

    然后,定义set:

    set<类型,myComp> s;

     

    (2)重载“<”操作符

    首先,在结构体中,重载“<”操作符,自定义排序规则

    struct 结构体

    {

            bool operator < (const 结构体类型 &a)

            {

                   ……

                   return(…);

             }

    };

    然后,定义set

    set<类型> s;

     

    【第四届蓝桥杯预选赛】错误票据

    题目描述:

    某涉密单位下发了某种票据,并要在年终全部收回。

    每张票据有唯一的ID号。全年所有票据的ID号是连续的,但ID的开始数码是随机选定的。

    因为工作人员疏忽,在录入ID号的时候发生了一处错误,造成了某个ID断号,另外一个ID重号。

    你的任务是通过编程,找出断号的ID和重号的ID。

    假设断号不可能发生在最大和最小号。

    要求程序首先输入一个整数N(N<100)表示后面数据行数。

    接着读入N行数据。

    每行数据长度不等,是用空格分开的若干个(不大于100个)正整数(不大于100000)

    每个整数代表一个ID号。

    要求程序输出1行,含两个整数m n,用空格分隔。

    其中,m表示断号ID,n表示重号ID

    输入:

    要求程序首先输入一个整数N(N<100)表示后面数据行数。

    接着读入N行数据。

    每行数据长度不等,是用空格分开的若干个(不大于100个)正整数(不大于100000)

    每个整数代表一个ID号。

    输出:

    要求程序输出1行,含两个整数m n,用空格分隔。

    其中,m表示断号ID,n表示重号ID

     

    样例输入:

    2

    5 6 8 11 9

    10 12 9

    样例输出:

    7 9

    五、map/multimap

    去重类问题

    可以打乱重新排列的问题

    有清晰的一对一关系的问题

    1. 特点:

    (1) map为单重映射、multimap为多重映射;

    (2) 主要区别是map存储的是无重复键值的元素对,而multimap允许相同的键值重复出现,既一个键值可以对应多个值。

    (3) map内部自建了一颗红黑二叉树,可以对数据进行自动排序,所以map里的数据都是有序的,这也是我们通过map简化代码的原因。

    (4)自动建立key-value的对应关系,key和value可以是你需要的任何类型。

    (5) key和value一一对应的关系可以去重。

     

    2. 创建对象:

    map<T1,T2> m;

    map<T1,T2, op> m;  //op为排序规则,默认规则是less<T>

     

    3. 基本操作:

    m.at(key);

    m[key];

    m.count(key);

    m.max_size(); //求算容器最大存储量

    m.size();  //容器的大小

    m.begin();

    m.end();

    m.insert(elem);

    m.insert(pos, elem);

    m.insert(begin, end);

     

    注意一下:该容器存储的是键值对,所以插入函数与其他容器稍有不同

    (1) 使用pair<>构造键值对对象

    map<int, float> m;

    m.insert(pair<int, float>(10,2.3));

     

    (2)使用make_pair()函数构建键值对对象

    map<int,float> m;

    m.insert(make_pair(10,2.3));

     

    (2) 使用value_type标志

    map<int, float> m;

    m.insert(map<int,float>::value_type(10,2.3));

     

    m[key] = value;   //m只能是map容器,不适用于multimap

     

    m.erase(pos);

    m.erase(begin,end);

    m.erase(key);

     

    使用 begin()和end()遍历map

     

    使用数组的方法遍历map

     

    使用find()查找

    用find函数来定位数据出现位置它返回的一个迭代器。

    当数据出现时,它返回数据所在位置的迭代器。

    如果map中没有要查找的数据,它返回的迭代器等于end函数返回的迭代器。

     

    map在题目中的应用

     

    去重:利用映射的一一对应性,把可能出现重复的数据设置为key值以达到去重的目的。

    排序:自定义Compare类(依葫芦画瓢)

    比如我建了一个学生-成绩的map,原先是按照学生名字的字典序              

    排序的。  

    如果我想按照降序呢?学生姓名长度呢?

    按照默认cmp的输出:

    降序输出:

    自定义cmp按照长度升序输出:

     

    计数

    假设定义一个map<string,int>map1,输入数据s,记为first,如果这个数据存在,map1[s]++;如果不存在,map1[s]=1;

    展开全文
  • STL容器比较

    2011-09-28 09:15:41
    STL容器比较STL容器比较STL容器比较
  • stl容器之顺序容器

    2019-08-23 16:58:30
    STL容器分为顺序容器和关联容器 其中顺序容器最常用的由vector,list,queue 1.vector vector: 向量容器,可以看作变长数组,长度可根据需要自行变化。 使用的头文件 #include<vector> 定义方式: vector&...

    STL容器分为顺序容器和关联容器

    其中顺序容器最常用的由vector,list,queue

    1.vector

    vector: 向量容器,可以看作变长数组,长度可根据需要自行变化。

    使用的头文件 #include<vector>

    定义方式: vector<typename> 数组名;//vector<int> ar;

    访问容器内数据的方式和普通数组相同,可以用ar[i]的形式,也可以用迭代器访问

    迭代器定义:vector<int>::iterator it;

    常用的接口函数:

    1.1 push_back();

    push_back(x);//将x插入到最后一个元素后面,时间复杂度O(1);

    1.2 insert();

    ar.insert(it,x);//向迭代器it位置前插入元素x,时间复杂度O(1)~O(n);

    ar.insert(it,num,x);//向迭代器it位置前插入num个元素x,时间复杂度O(n)~O(n^2)

    ar.insert(it,begin,end);//向it位置前插入从begin位置到end位置的值O(n)~O(N^2)

    1.3 size();

    用来获取vector中元素个数,时间复杂度O(1)

    1.4 clear();

    清空vector中元素,时间复杂度O(n);

    1.5 pop_back();

    删除vector中最后1个元素

    1.6 erase();

    删除vector中某个元素或某个范围内的元素

    erase(position);//删除一个元素(position)

    erase(first,last);//删除first到last范围内的元素

    其中position,first,last都是vector迭代器

     

    2.list

    底层实现为双向链表,与向量相比,插入和删除更高效,但不能按下标随机访问

    使用的头文件#include<list>

    push_back();//尾部插入一个元素

    push_front();//头部插入一个元素

    size();//返回list中元素个数

    sort();//给list中元素排序

    pop_back();//尾部删除

    pop_front();//头部删除

    erase();//删除一个元素

    insert();//插入一个元素到list中

    clear();//删除所有元素

     

    3.queue

    queue:队列。使用的头文件#include<queue>

    push();//入队

    pop();//出队

    size();//返回队列中元素的个数

    empty();//判断队列是否为空,若为空,返回true,否则返回false

    front();//返回队头元素(第一个入队的元素)

    back();//返回队尾元素(最后一个入对的元素)

     

     

     

     

     

     

    展开全文
  • 主要介绍了C++ STL容器stack和queue详解的相关资料,需要的朋友可以参考下
  • c++STL容器讲义与演示

    2018-01-25 16:04:17
    c++STL容器讲义与演示,对STL初学者帮助很大。。。。。。
  • ACM常用STL容器

    2020-01-27 18:12:00
    1 // STL(标准模板库),由三大部分组成:容器,算法,迭代器 2 3 4 // STL六大组件:container(容器),algorthm(算法),iterator(迭代器) 5 // function object(仿... 7 // STL容器 8 9 // vector 10 // ...
  • C++中STL容器总结

    多人点赞 2020-05-03 11:09:33
    STL容器1、容器分类 1、容器分类 STL中通常将容器分为三类:顺序容器、关联容器和容器适配器。 1、顺序容器 是一种各元素之间有顺序关系的线性表,是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置...
  • STL容器与迭代器

    2019-08-20 17:41:03
    STL容器 STL容器分为三类,顺序容器、关联容器和容器适配器。 顺序容器有vector、list、deque。 vector是矢量容器,底层是一个动态开辟的一维数组,每次扩容为原来的2倍。 vector容器对象常用方法有push_back、pop_...
  • c++ stl容器set成员函数:begin()--返回指向第一个元素的迭代器 c++ stl容器set成员函数:clear()--清除所有元素 c++ stl容器set成员函数:count()--返回某个值元素的个数 c++ stl容器set成员函数:empty()--如果集合...
  • 常见STL容器总结

    千次阅读 2018-08-27 15:29:46
    STL容器主要分为 顺序容器 vector(向量容器) deque(双端队列容器) list(双向链表) 关联容器 set(单重集合) multiset(双重集合) map(单重映射表) multimap(多重映射表) 容器适配器 stack(栈) queue(队列) prority_...
  • 1:STL容器

    2016-03-26 17:00:07
    C++标准程序库提供了如下容器:序列容器、关联容器、容器配接器和其它容器STL容器。序列容器包括vector、deque和list;关联容器包括map、multimap、set和multiset;容器配接器包括stack、queue和priority queue,...
  • 关于STL容器效率问题

    2020-04-18 09:23:43
    关于STL容器效率问题 近期遇到一个项目,需要临时存储大量的数据并进行查找遍历运算。习惯于用Vector的我毫不犹豫的用Vector,后来在编码的过程中发现还要进行查找,删除、插入等一系列的操作。所以就要对容器的应用...
  • STL容器总结

    2013-09-12 14:52:01
    一. 种类: 标准STL序列容器:vector、string、deque和list。标准STL关联容器:set、multiset、map和multimap。非标准序列容器slist和rope。slist是一个单向链表,rope本质上是一...几种标准非STL容器,包括数组、bits
  • C++ container容器 STL容器包括顺序式容器和关联式容器。 顺序式容器 顺序容器包括:可变长动态数组 vector、双端队列 deque、双向链表 list、队列queue、有限队列p 关联式容器 ...
  • C++ STL容器类型的内存释放
  • STL容器用法详解

    千次阅读 2017-01-12 21:09:57
    参考:http://www.cnblogs.com/duoduo369/archive/2012/04/12/2439118.html 参考:... 1.STL容器分类: STL的容器可以分为以下几个大类:  一 顺序容器,vector, list, deque, string,s
  • 几种STL容器的基本用法几种STL容器的基本用法
  • STL容器的底层实现

    2019-03-02 23:06:27
    STL容器 底层实现 备注 近容器 string - 数组[] - 顺序容器 vector 一维数组 list 双向链表 deque 二维数组 关联容器 set 红黑树 不...
  • 标准非STL容器 : bitset

    千次阅读 2016-04-19 11:12:48
    标准非STL容器是指“可以认为它们是容器,但是他们并不满足STL容器的所有要求”。前文提到的容器适配器stack、queue及priority_queue都是标准非STL容器的一部分。此外,valarray也是标准非STL容器。 bitset:一种...
  • STL 容器简介

    千次阅读 2010-07-01 15:42:00
    STL 容器简介
  • STL容器的使用

    2016-06-07 19:14:58
    */ ... * All rights reserved. * 文件名:text.cpp * 作者:常轩 * 微信公众号:Worldhello * 完成日期:2016年6... * 问题描述:STL容器的使用 * 程序输入:无 * 程序输出:见运行结果 */ //STL容器的使用 #incl
  • STL容器长度复杂度

    2019-03-11 20:36:15
    其余STL容器可按下面方法自测。 求时间复杂度方法: #include&lt;iostream&gt; #include&lt;list&gt; #include&lt;ctime&gt; #include&lt;vector&gt; using namespace std; ...
  • STL ( Standard Template Library) 的目的是标准化组件,这样就不用重新开发,可以使用现成的组件。...STL主要包括容器(containers)和算法(algorithms),以下是自己对几个主要的STL容器的理解。 ...
  • 文章目录c++ STL 容器 中 swap的使用vector容器中swap的使用 c++ STL 容器 中 swap的使用 vector容器中swap的使用 主要涉及以下内容: size 和 capacity 区别 swap的基本用法 swap在缓存队列中的使用 可以从下面...
  • STL 容器范围

    2020-02-07 21:11:02
    Standard Template Library (STL) 容器范围 1. 容器 容器是用来存储和组织其他对象的对象。 2. Standard Template Library (STL) 容器范围 STL 提供各种容器类的模板,可以在大范围的应用程序上下文中使用这些模板。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,216
精华内容 13,286
关键字:

stl容器