精华内容
下载资源
问答
  • 关联容器和顺序容器

    2017-10-27 20:41:56
    1:关联容器和顺序容器 c++中有两种类型的容器:顺序容器和关联容器,顺序容器主要有:vector、list、deque等。其中vector表示一段连续的内存地址,基于数组的实现,list表示非连续的内存,基于链表实现。deque与...

    1:关联容器和顺序容器

      c++中有两种类型的容器:顺序容器和关联容器,顺序容器主要有:vector、list、deque等。其中vector表示一段连续的内存地址,基于数组的实现,list表示非连续的内存,基于链表实现。deque与vector类似,但是对于首元素提供删除和插入的双向支持。关联容器主要有map和set。map是key-value形式的,set是单值。map和set只能存放唯一的key值,multimap和multiset可以存放多个相同的key值。

    容器类自动申请和释放内存,我们无需new和delete操作。


    2:顺序容器的介绍

    1) vector,需要包含头文件#include < vector >

    主要的操作有

    //1.定义和初始化
         vector<int> vec1;    //默认初始化,vec1为空
         vector<int> vec2(vec1);  //使用vec1初始化vec2
         vector<int> vec3(vec1.begin(),vec1.end());//使用vec1初始化vec2
         vector<int> vec4(10);    //10个值为0的元素
         vector<int> vec5(10,4);  //10个值为4的元素
    
         //2.常用操作方法
         vec1.push_back(100);            //尾部添加元素
         int size = vec1.size();         //元素个数
         bool isEmpty = vec1.empty();    //判断是否为空
         cout<<vec1[0]<<endl;        //取得第一个元素
         vec1.insert(vec1.end(),5,3);    //从vec1.back位置插入5个值为3的元素
         vec1.pop_back();              //删除末尾元素
         vec1.erase(vec1.begin(),vec1.begin()+2);//删除vec1[0]-vec1[2]之间的元素,不包括vec1[2]其他元素前移,是一个左闭右开的区间
        cout<<(vec1==vec2)?true:false;  //判断是否相等==、!=、>=、<=...
         vector<int>::iterator iter = vec1.begin();    //获取迭代器首地址
        vector<int>::const_iterator c_iter = vec1.begin();   //获取const类型迭代器
        vec1.clear();                 //清空元素
    
         //3.遍历
         //下标法
        int length = vec1.size();
         for(int i=0;i<length;i++)
         {
            cout<<vec1[i];
         }
         cout<<endl<<endl;
         //迭代器法
        vector<int>::iterator iter = vec1.begin();
         for(;iter != vec1.end();iter++)
         {
            cout<<*iter;
         }

    2) list

    list是STL实现的双向链表,与向量vector想比,它允许快速的插入和删除,但是随机访问却是比较慢,需要添加头文件#include< list>

    主要的操作

        //1.定义和初始化
        list<int> lst1;          //创建空list
        list<int> lst2(3);       //创建含有三个元素的list
        list<int> lst3(3,2); //创建含有三个元素为2的list
        list<int> lst4(lst2);    //使用lst2初始化lst4
        list<int> lst5(lst2.begin(),lst2.end());  //同lst4
    
        //2.常用操作方法
        lst1.assign(lst2.begin(),lst2.end());  //分配值,3个值为0的元素
        lst1.push_back(10);                    //末尾添加值
        lst1.pop_back();                   //删除末尾值
        lst1.begin();                      //返回首值的迭代器
        lst1.end();                            //返回尾值的迭代器
        lst1.clear();                      //清空值
        bool isEmpty1 = lst1.empty();          //判断为空
        lst1.erase(lst1.begin(),lst1.end());                        //删除元素
        lst1.front();                  //返回第一个元素的引用(与begin()要区分开)
        lst1.back();                  //返回最后一个元素的引用(与end()要区分开)
        lst1.insert(lst1.begin(),3,2);         //从指定位置插入个3个值为2的元素
        lst1.rbegin();                         //返回第一个元素的前向指针
        lst1.remove(2);                        //相同的元素全部删除
        lst1.reverse();                        //反转
        lst1.size();                       //含有元素个数
        lst1.sort();                       //排序
        lst1.unique();                         //删除相邻重复元素
    
        //3.遍历
        //迭代器法
        for(list<int>::const_iterator iter = lst1.begin();iter != lst1.end();iter++)
        {
           cout<<*iter;
        }

    3) deque

      deque容器类与vector类似,支持随机访问和快速插入和删除,与vector不同,deque还支持从开始端插入数据:push_front。其余的类似vector操作方法的使用.
      


    3:关联容器的介绍

    1)map的介绍

      c++map容器提供一个键值对(key/value)容器,map与multimap差别仅仅在于multimap允许一个键对应多个值。需要包含头文件#include< map >。对于迭代器来说,可以修改实值,而不能修改key。map会根据key自动排序.

    常用操作如下:

        //1.定义和初始化
        map<int,string> map1;                  //空map
    
        //2.常用操作方法
        map1[3] = "Saniya";                    //添加元素
        map1.insert(map<int,string>::value_type(2,"Diyabi"));//插入元素
        //map1.insert(pair<int,string>(1,"Siqinsini"));
        map1.insert(make_pair<int,string>(4,"V5"));
        string str = map1[3];                  //根据key取得value,key不能修改
        map<int,string>::iterator iter_map = map1.begin();//取得迭代器首地址
        int key = iter_map->first;             //取得key
        string value = iter_map->second;       //取得value
        map1.erase(iter_map);                  //删除迭代器数据
        map1.erase(3);                         //根据key删除value
        map1.size();                       //元素个数
        map1.empty();                       //判断空
        map1.clear();                      //清空所有元素
    
        //3.遍历
        for(map<int,string>::iterator iter = map1.begin();iter!=map1.end();iter++)
        {
           int keyk = iter->first;
           string valuev = iter->second;
        }

    2) set集合

    set的含义是集合,它是一个有序的容器,里面的元素都是排序好的支持插入、删除、查找等操作,就像一个集合一样,所有的操作都是严格在logn时间内完成,效率非常高。set和multiset的区别是:set插入的元素不能相同,但是multiset可以相同,set默认是自动排序的,使用方法类似list。


    4:几种容器的比较

    1) vector

    内部数据结构:数组。

    在末尾增加或者删除元素所需时间与元素数目无关,在中间或者开头增加或者删除元素所需时间是随元素数目呈线性变化。

    2) deque

    内部数据结构是:数组

    随机访问每个元素,所需要的时间为常量。在开头和末尾增加元素所需时间与元素数目无关,在中间增加或删除所需时间随元素数目呈线性变化。

    3) list

    内部数据结构:双向环状链表

    不能随机访问一个元素,可双向遍历,在开头,末尾和中间的任何地方增加或者删除元素所需时间都是常量。

    4) set

    键和值相等。

    键唯一

    元素默认按升序排列、

    5) map

    键唯一,

    元素默认按键的升序排列


    5:关于迭代器失效的问题、小心使用STL中的erase

    先看下面一段代码:

    #include "stdafx.h"
    #include<iostream>
    #include<vector>
    
    using namespace std;
    
    
    int main()
    {
        vector<int> vect;
        for(int i = 0; i < 10; i++ )
        {
            vect.push_back(i);
        }
    
        vector<int>::iterator iter = vect.begin();
        for(; iter != vect.end(); iter++ )
        {
            if( *iter % 2 == 0 )
            {
                vect.erase(iter);
            }
        }
    
        return 0;
    }

    咋一看这一段代码好像没有什么问题
    但是运行之后的结果为:

    程序直接crash了。iter是指向vector这个容器中的某个元素,如果不是在for、while循环中,erase删除元素是没有问题的,但是如果在for、while循环中对容器迭代,删除其中符合条件的所有元素,就可能出现问题。vect.erase(iter)之后,iter及其后面的迭代器已经失效了,不应该再使用这些迭代器了,再执行it++,其行为是未定义的。其它容器也会遇到迭代器失效的问题。

      对于vector被删除元素的迭代器以及指向后面元素的迭代器全部失效。对于deque在首部或尾部删除元素则只会使指向被删除元素的迭代器失效,任何其它位置的插入和删除操作将使指向该容器元素的所有迭代器失效。

      对于list仅有指向被删除元素的迭代器失效。为什么不同容器迭代器失效情况有差别呢?这主要与各容器的数据结构有关。

      那如何在迭代容器时删除其中的元素?各容器通用的做法如下:看下面的例子

    #include "stdafx.h"
    #include<iostream>
    #include<vector>
    #include<map>
    #include<deque>
    #include<list>
    
    using namespace std;
    
    
    int main()
    {
        vector<int> vect;
        for(int i = 0; i < 10; i++ )
        {
            vect.push_back(i);
        }
        vector<int>::iterator iter = vect.begin();
        for(; iter != vect.end(); )
        {
             if( *iter % 2 == 0 )
             {
                //vect.erase(iter++); //测试 使用vect.erase(iter++) 行不通,我看网上有些人写到这种方式也可行?表示奇怪。
                 iter = vect.erase(iter); 
             }
             else
             {
                 iter++;
             }
        }
    
       //下面是对deque的测试
        deque<int> myDeque;
        for( int i = 0; i < 10; i++ )
        {
            myDeque.push_back(i);
        }
        deque<int>::iterator deiter = myDeque.begin();
        for(; deiter != myDeque.end();)
        {
            if( *deiter % 2 == 0 )
            {
                //myDeque.erase(deiter++); //同样这里vect.erase(iter++) 行不通
                deiter = myDeque.erase(deiter);
            }
            else
            {
                deiter++;
            }
        }
    
        //下面对list的测试//
        list<int> myList;
        for( int i = 0; i < 10; i++ )
        {
            myList.push_back(i);
        }
        list<int>::iterator listiter = myList.begin();
        for(; listiter != myList.end();)
        {
            if( *listiter % 2 == 0 )
            {
                //myList.erase(listiter++);
                listiter = myList.erase(listiter); //对于list这两种方式都可以的.因为对于list来说仅有指向被删除元素的迭代器失效,并不会导致所有的迭代器失效.
            }
            else
            {
                listiter++;
            }
        }
        //下面是对map的测试/
        map<int,int> myMap;
        myMap[0] = 1;
        myMap[1] = 2;
        myMap[2] = 3;
        myMap[3] = 4;
        map<int,int>::iterator it = myMap.begin();
        for(; it != myMap.end(); )
        {
            if( (it->second) % 2 == 0 )
            {
                myMap.erase(it++);
                //it = myMap.erase(it); //对于map这两种方法都可以 c++11 才开始支持返回当前的迭代器,之前的可能没有返回值,所以这种方法不管用
            }
            else
            {
                it++;
            }
        }
        //set 跟map一样///
        system("pause");
        return 0;
    }

    本文转载了http://www.cnblogs.com/cxq0017/p/6555533.html

    展开全文
  • 关联容器和顺序容器的差别

    千次阅读 2014-08-23 09:08:21
    关联容器和顺序容器的本质差别在于关联容器通过键(key

    关联容器和顺序容器的本质差别在于关联容器通过键(key)存储和读取元素,顺序容器则通过元素在容器中的位置顺序存储和访问元素。


    顺序容器list、vector、deque和关联容器map、set类型分别适用的情况:

    (1)list 类型适用于需要在容器中间插入和删除元素的情况,例如以无序方式读入一系列学生数据,并按学号顺序存储。

    (2)vector类型使用与随机访问元素的情况,例如在序号为1....n的一系列人员当中,访问第x个人的信息。

    (3)deque类型适用于需要在容器的尾部或首部插入和删除元素的情况。例如,对服务窗口进行管理,先来的顾客先得到服务。

    (4)map类型使用与需要键-值对的集合的情况。例如,字典、电话簿的建立和使用。

    (5)set类型使用于需要使用键集合的情况,例如,黑名单的建立和使用。


    map和set的差别以及各自使用的情况

    map和set的差别在于:map容器是键-值对的集合,而set只是键的集合;map类型适用于了解键与值的对应的情况,例如,字典(需要了解单词(键) 与解释(值)的对应情况),而set类型适用于只需判断某值是否存在的情况,例如,判断某人的名字是否在黑名单中。


    set和list容器的主要差别和各自使用的情况

    set容器和List容器的主要差别在于set容器中的元素不能修改,而list容器中的元素没有这方面的显示;set容器适用于保存元素值不变的集合,而list容器适用于保存发生变化的元素。



    展开全文
  • 关联容器和顺序容器的本质区别 关联容器和顺序容器的本质区别在于:  关联容器通过键(KEY)存储和读取元素,  而顺序容器则通过元素在容器中的位置存储和访问元素 ...

    关联容器和顺序容器的本质区别在于:

      关联容器通过键(KEY)存储和读取元素,

      而顺序容器则通过元素在容器中的位置存储和访问元素

    posted on 2012-04-10 10:42 anywei 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/anywei/archive/2012/04/10/2440113.html

    展开全文
  • 关联容器和顺序容器的本质区别在于:关联容器通过键(KEY)存储和读取元素,而顺序容器则通过元素在容器中的位置存储和访问元素

    关联容器和顺序容器的本质区别在于:关联容器通过键(KEY)存储和读取元素,而顺序容器则通过元素在容器中的位置存储和访问元素

    展开全文
  • 参考链接:https://blog.csdn.net/weixin_43691058/article/details/88556471
  • 关联容器顺序容器的区别

    千次阅读 2013-07-04 10:29:15
    关联容器(Associative Container)与顺序容器(Sequential Container)的本质区别在于:关联容器是通过键(key)存储读取元素的,而顺序容器则通过元素在容器中的位置顺序存储访问元素。 以前一直以为关联容器都是...
  • 顺序容器和关联容器

    2019-01-08 23:00:08
    顺序容器:vector;list;deque(双向口队列);queue(单向口队列);stack(栈 );heap(堆);priority_queue (按键值大小排序) 关联容器:set;map;multiset;multimap; setmap 的insert/erase set.insert...
  • 顺序容器和关联容器图示: 1.顺序容器和关联容器的区别: ①顺序容器只有实值val。 ②关联容器的一个元素包含两个部分:键值对(key-value) 即&lt;k值(键值)|实值&gt;。 ③顺序容器不涉及排序,关联容器内部...
  • 容器主要分为顺序容器和关联容器。 一,顺序容器 vector--连续存储的元素,单向的 list----由节点组成的不连续存储的双向鏈表 deque--连续存储的元素,双向的 1,顺序容器主要分为vector, deque, list。 ...
  • 顺序容器和关联容器的比较

    千次阅读 2016-04-17 21:55:58
    (2) C++容器:顺序容器关联容器 2、关于顺序容器和关联容器的一些区别简要总结如下: (1)关联容器(Associative Container)与顺序容器(Sequential Container)的本质区别在于:关联容器是通过键(key)存储和读取元素...
  • 1.什么是STL STL(Standard Template Library),即标准模板库,是一个具有...该库包含了诸多在计算机科学领域里所常用的基本数据结构基本算法。为广大C++程序员们提供了一个可扩展的应用框架,高度体现了软件...
  • 关联容器和顺序容器有着根本的不同:关联容器中的元素是按关键字来保存和访问的。与之相对,顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的。  关联容器支持高效的关键字查找和访问。两个主要的关联...
  • 关联容器和顺序容器有着根本的不同:关联容器中的元素是按关键字来保存和访问的。与之相对,顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的。 虽然关联容器的很多行为与顺序容器相同,但其不同之处反映...
  • 关联容器

    2020-10-24 21:10:53
    关联容器和顺序容器根本不同 两个主要的关联容器类型是map和set 使用map 关联容器(有序的和无序的) 在集合类型中,关键字类型就是元素类型;在映射类型中,关键字类型是元素的第一部分的类型。 set的迭代器是const...
  • 关联容器(Associative Container)与顺序容器(Sequential Container)的本质区别在于:关联容器是通过键(key)存储读取元素的,而顺序容器则通过元素在容器中的位置顺序存储访问元素。 ...
  • 一个合格的容器(Container)必须支持增删改查,C++的顺序容器和关联容器也不例外。 不同于insert和search,erase操作涉及到多种情况,尤其是和迭代器相结合的时候。 本文总结常用C++常用容器的erase的正确做法。 ...
  • C++学习基础四——顺序容器和关联容器顺序容器:vector,list,queue1.顺序容器的常见用法: #include <vector> #include <list> #include <queue> (1)vector声明 ...
  • C++容器之关联容器

    2020-12-20 21:12:14
    关联容器和顺序容器有根本的不同: 关联容器中的元素是按关键字来保存和访问的。 顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的。 关联容器支持高效的关键字查找和访问。两个主要的**关联容器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,458
精华内容 583
关键字:

关联容器和顺序容器