精华内容
下载资源
问答
  • 下面小编就为大家带来一篇vector list map 遍历删除制定元素 防止迭代器失效的实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • STL中vector和list的区别

    千次阅读 2019-08-05 16:31:08
    vector和list在底层结构、随机访问、插入删除、空间利用率、迭代器、迭代器失效、使用场景这七个方面进行了总结。

    底层结构

      vector的底层结构是动态顺序表,在内存中是一段连续的空间。
      list的底层结构是带头节点的双向循环链表,在内存中不是一段连续的空间。

    随机访问

      vector支持随机访问,可以利用下标精准定位到一个元素上,访问某个元素的时间复杂度是O(1)。
      list不支持随机访问,要想访问list中的某个元素只能是从前向后或从后向前依次遍历,时间复杂度是O(N)。

    插入和删除

      vector任意位置插入和删除的效率低,因为它每插入一个元素(尾插除外),都需要搬移数据,时间复杂度是O(N),而且插入还有可能要增容,这样一来还要开辟新空间,拷贝元素,是旧空间,效率会更低。
      list任意位置插入和删除的效率高,他不需要搬移元素,只需要改变插入或删除位置的前后两个节点的指向即可,时间复杂度为O(1)。

    空间利用率

      vector由于底层是动态顺序表,在内存中是一段连续的空间,所以不容易造成内存碎片,空寂爱你利用率高,缓存利用率高。
      list的底层节点动态开辟空间,小姐点容易造成内存碎片,空间利用率低,缓存利用率低。

    迭代器

      vector的迭代器是原生态指针。
      list对原生态指针(节点的指针)进行了封装。

    迭代器失效

      vector在插入元素时的时候,要重新给所有的迭代器赋值,因为插入元素有可能导致扩容,只是原来的迭代器失效,删除元素时当前迭代器同样需要重新赋值,否则会失效。
      list在插入元素的时候不会导致迭代器实现,删除元素的时候指挥导致当前迭代器失效,其他的迭代器不会受到影响。

    使用场景

      vector适合需要高效率存储,需要随机访问,并且不管行插入和删除效率的场景。
      list适合有大量的插入和删除操作,并且不关心随机访问的场景

    展开全文
  • vector和list的区别

    万次阅读 2018-10-15 21:55:09
    vector和list的区别

    对于vector和list而言,

    1. vector和数组类似,拥有一段连续的内存空间,并且起始地址不变。vector和数组类似,拥有一段连续的内存空间,并且起始地址不变。
      因此,它能够高效地进行随机存取,时间复杂度是O(1)
      但是,因为其内存空间是连续的,所以在进行插入和删除操作时,会造成内存块的拷贝,因此时间复杂度为O(n)
      另外,当数组内存空间不够时,会重新申请一块内动空间并进行内存拷贝。
    2. list是由双向链表实现的,因此内存空间是不连续的。
      其只能通过指针访问数据,所以list的随机存取效率很低,时间复杂度为O(n)
      不过由于链表自身的特点,能够进行高效的插入和删除
    3. vector和list对于迭代器的支持不同。
      相同点在于,vector< int >::iterator和list< int >::iterator都重载了 “++ ”操作。
      而不同点在于,在vector中,iterator支持 ”+“、”+=“,”<"等操作。而list中则不支持。
    展开全文
  • list的三种循环遍历方式 // int的类型 #include <iostream> #include <list> //using namespace std; int main() { //================================================================= std::...

    list的三种循环遍历方式

    // int的类型

    #include <iostream>
    #include <list>
    
    //using namespace std;
    
    int main() {
    
    //=================================================================
        std::list<int> ls;
    
        ls.push_back(120);
        ls.push_back(110);
        ls.push_front(130);	// list有push_front,vector没有push_front
        ls.push_front(140);
        ls.push_front(150);
        ls.push_back(100);
    
    
        for (int i = 0; i < ls.size(); ++i) {
    //        std::cout << ls[i] << std::endl;	// list不可以这么用,vector可以这么用
        }
    
        
        for (int ele:ls) {
            std::cout << "基于范围的for循环:" << ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
        
        
        std::list<int>::iterator ele;
        for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << *ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        ls.pop_back();
        ls.pop_front();	// list有pop_front,vector没有pop_front
        
        ls.emplace_back(200);
        ls.emplace_front(300);
        
        return 0;
    }
    

    // float的类型

    #include <iostream>
    #include <list>
    
    //using namespace std;
    
    int main() {
    
    //=================================================================
        std::list<float> ls;
    
        ls.push_back(120.123);
        ls.push_back(110.123);
        ls.push_front(130.123);	// list有push_front,vector没有push_front
        ls.push_front(140.123);
        ls.push_front(150.123);
        ls.push_back(100.123);
    
    
        for (int i = 0; i < ls.size(); ++i) {   // TODO 这里i不要用float
    //        std::cout << ls[i] << std::endl;	// list不可以这么用,vector可以这么用
        }
    
    
        for (float ele:ls) {
            std::cout << "基于范围的for循环:" << ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    
        std::list<float>::iterator ele;
        for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << *ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        ls.pop_back();
        ls.pop_front();	// list有pop_front,vector没有pop_front
    
        ls.emplace_back(200.123);
        ls.emplace_front(300.123);
        
        return 0;
    }
    

    // string的类型

    #include <iostream>
    #include <list>
    
    //using namespace std;
    
    int main() {
    
    //=================================================================
        std::list<std::string> ls;
    
        ls.push_back("CCC");
        ls.push_back("BBB");
        ls.push_front("DDD");	// list有push_front,vector没有push_front
        ls.push_front("EEE");
        ls.push_front("FFF");
        ls.push_back("AAA");
    
    
    //    for (std::string i = 0; i < ls.size(); ++i) {
            std::cout << ls[i] << std::endl;	// 不能这么用
    //    }
    
        
        for (std::string ele:ls) {
            std::cout << "基于范围的for循环:" << ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
        
        
        std::list<std::string>::iterator ele;
        for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << *ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        ls.pop_back();
        ls.pop_front();	// list有pop_front,vector没有pop_front
    
        ls.emplace_back("XXX");
        ls.emplace_front("YYY");
        
        return 0;
    }
    

    // class的类型

    #include <iostream>
    #include <list>
    
    //using namespace std;
    
    class A {
    public:
        std::string name = "";
        int age = 0;
    
        A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
            std::cout << "执行了构造函数 " << name << std::endl;
        }
    
        ~A() {
            std::cout << "执行了析构函数 " << name << std::endl;
        }
    };
    
    
    int main() {
    
    //=================================================================
        A a1("张一", 10);
        A a2("张二", 20);
        A a3("张三", 30);
        A a4("张四", 40);
    
        std::list<A> ls;
    
        ls.push_front(a3);    // 这里也会执行构造函数创建对象
        ls.push_back(a2);
        ls.push_back(a1);
        ls.push_front(a4);	// list有push_front,vector没有push_front
    
    
    //    for (A i = 0; i < ls.size(); ++i) {
            std::cout << ls[i] << std::endl;	// 不能这么用
    //    }
    
        
        for (A ele:ls) {
            std::cout << "基于范围的for循环:" << ele.name << ele.age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
        
        std::list<A>::iterator ele;
        for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << (*ele).name << (*ele).age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        ls.pop_back();
        ls.pop_front();	// list有pop_front,vector没有pop_front
    
        ls.emplace_back(A("张五", 50));
        ls.emplace_front(A("张六", 60));
        
        return 0;
    }
    

    // class的类型(指针)

    #include <iostream>
    #include <list>
    
    //using namespace std;
    
    class A {
    public:
        std::string name = "";
        int age = 0;
    
        A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
            std::cout << "执行了构造函数 " << name << std::endl;
        }
    
        ~A() {
            std::cout << "执行了析构函数 " << name << std::endl;
        }
    };
    
    
    int main() {
    
    //=================================================================
        A a1("张一", 10);
        A a2("张二", 20);
        A a3("张三", 30);
        A a4("张四", 40);
    
        std::list<A*> ls;		// 这里用了指针
    
        ls.push_front(&a3);    // 这里不会执行构造函数创建对象
        ls.push_back(&a2);
        ls.push_back(&a1);
        ls.push_front(&a4);		// list有push_front,vector没有push_front
    
    
    //    for (A* i = 0; i < ls.size(); ++i) {
            std::cout << ls[i] << std::endl;	// 不能这么用
    //    }
    
    
        for (A* ele:ls) {
            std::cout << "基于范围的for循环:" << ele->name << ele->age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    
        std::list<A*>::iterator ele;
        for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << (*ele)->name << (*ele)->age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        ls.pop_back();
        ls.pop_front();	// list有pop_front,vector没有pop_front
        
        A a5("张五", 50);
        A a6("张六", 60);
        ls.emplace_back(&a5);
        ls.emplace_front(&a6);
        
        return 0;
    }
    

    vector的三种循环遍历方式

    // int的类型

    #include <iostream>
    #include <vector>
    
    //using namespace std;
    
    int main() {
    
    //=================================================================
        std::vector<int> v;
    
        v.push_back(120);
        v.push_back(110);
    //    v.push_front(130);	// list有push_front,vector没有push_front
    //    v.push_front(140);
    //    v.push_front(150);
        v.push_back(100);
    
    
        for (int i = 0; i < v.size(); ++i) {
            std::cout << v[i] << std::endl;	// list不可以这么用,vector可以这么用
        }
    
    
        for (int ele:v) {
            std::cout << "基于范围的for循环:" << ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    
        std::vector<int>::iterator ele;
        for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << *ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        v.pop_back();
    //    v.pop_front();	// list有pop_front,vector没有push_front
        
        v.emplace_back(200);
    //    v.emplace_front(300);	// list有emplace_front,vector没有emplace_front
        
        return 0;
    }
    

    // float的类型

    #include <iostream>
    #include <vector>
    
    //using namespace std;
    
    int main() {
    
    //=================================================================
        std::vector<float> v;
    
        v.push_back(120.123);
        v.push_back(110.123);
    //    v.push_front(130.123);	// list有push_front,vector没有push_front
    //    v.push_front(140.123);
    //    v.push_front(150.123);
        v.push_back(100.123);
    
    
        for (int i = 0; i < v.size(); ++i) {   // TODO 这里i不要用float
            std::cout << v[i] << std::endl;	// list不可以这么用,vector可以这么用
        }
    
    
        for (float ele:v) {
            std::cout << "基于范围的for循环:" << ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    
        std::vector<float>::iterator ele;
        for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << *ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        v.pop_back();
    //    v.pop_front();	// list有pop_front,vector没有push_front
            
        v.emplace_back(200.123);
    //    v.emplace_front(300.123);	// list有emplace_front,vector没有emplace_front
        
        return 0;
    }
    

    // string的类型

    #include <iostream>
    #include <vector>
    
    //using namespace std;
    
    int main() {
    
    //=================================================================
        std::vector<std::string> v;
    
        v.push_back("CCC");
        v.push_back("BBB");
    //    v.push_front("DDD");	// list有push_front,vector没有push_front
    //    v.push_front("EEE");
    //    v.push_front("FFF");
        v.push_back("AAA");
    
    
    //    for (std::string i = 0; i < v.size(); ++i) {
            std::cout << ls[i] << std::endl;	// 不能这么用
    //    }
    
    
        for (std::string ele:v) {
            std::cout << "基于范围的for循环:" << ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    
        std::vector<std::string>::iterator ele;
        for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << *ele << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        v.pop_back();
    //    v.pop_front();	// list有pop_front,vector没有push_front
            
        v.emplace_back("XXX");
    //    v.emplace_front("YYY");	// list有emplace_front,vector没有emplace_front
        
        return 0;
    }
    

    // class的类型

    #include <iostream>
    #include <vector>
    
    //using namespace std;
    
    class A {
    public:
        std::string name = "";
        int age = 0;
    
        A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
            std::cout << "执行了构造函数 " << name << std::endl;
        }
    
        ~A() {
            std::cout << "执行了析构函数 " << name << std::endl;
        }
    };
    
    
    int main() {
    
    //=================================================================
        A a1("张一", 10);
        A a2("张二", 20);
        A a3("张三", 30);
        A a4("张四", 40);
    
        std::vector<A> v;
    
    //    v.push_front(a3);	// list有push_front,vector没有push_front
        v.push_back(a2);       // 这里也会执行构造函数创建对象
        v.push_back(a1);
    //    v.push_front(a4);
    
    
    //    for (A i = 0; i < v.size(); ++i) {
            std::cout << ls[i] << std::endl;	// 不能这么用
    //    }
    
    
        for (A ele:v) {
            std::cout << "基于范围的for循环:" << ele.name << ele.age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    
        std::vector<A>::iterator ele;
        for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << (*ele).name << (*ele).age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        v.pop_back();
    //    v.pop_front();	// list有pop_front,vector没有push_front
            
        v.emplace_back(A("张五", 50));
    //    v.emplace_front(A("张六", 60));	// list有emplace_front,vector没有emplace_front
    
        return 0;
    }
    

    // class的类型(指针)

    #include <iostream>
    #include <vector>
    
    //using namespace std;
    
    class A {
    public:
        std::string name = "";
        int age = 0;
    
        A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
            std::cout << "执行了构造函数 " << name << std::endl;
        }
    
        ~A() {
            std::cout << "执行了析构函数 " << name << std::endl;
        }
    };
    
    
    int main() {
    
    //=================================================================
        A a1("张一", 10);
        A a2("张二", 20);
        A a3("张三", 30);
        A a4("张四", 40);
    
        std::vector<A*> v;		// 这里用了指针
    
    //    v.push_front(&a3);	// list有push_front,vector没有push_front
        v.push_back(&a2);       // 这里不会执行构造函数创建对象
        v.push_back(&a1);
    //    v.push_front(&a4);
    
    
    //    for (A* i = 0; i < v.size(); ++i) {
            std::cout << ls[i] << std::endl;	// 不能这么用
    //    }
    
    
        for (A* ele:v) {
            std::cout << "基于范围的for循环:" << ele->name << ele->age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    
        std::vector<A*>::iterator ele;
        for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
            std::cout << "基于容器的for循环:" << (*ele)->name << (*ele)->age << std::endl;
        }
        std::cout << "-----------------------------" << std::endl;
    
    //=================================================================
        v.pop_back();
    //    v.pop_front();	// list有pop_front,vector没有push_front
        
        A a5("张五", 50);
        A a6("张六", 60);
        v.emplace_back(&a5);
    //    v.emplace_front(&a6);	// list有emplace_front,vector没有emplace_front
        
        return 0;
    }
    
    展开全文
  • vector和list区别

    万次阅读 2018-08-30 21:26:32
    vector和built-in数组类似,它拥有一段连续的内存空间,并且起始地址不变,因此它能非常好的支持随即存取,即[]操作符,但由于它的内存空间是连续的,所以在中间进行插入删除会造成内存块的拷贝,另外,当该数组后...

    stl提供了三个最基本的容器:vector,list,deque。

    vector和built-in数组类似,它拥有一段连续的内存空间,并且起始地址不变,因此它能非常好的支持随即存取,即[]操作符,但由于它的内存空间是连续的,所以在中间进行插入和删除会造成内存块的拷贝,另外,当该数组后的内存空间不够时,需要重新申请一块足够大的内存并进行内存的拷贝。这些都大大影响了vector的效率。

    list就是数据结构中的双向链表(根据sgi stl源代码),因此它的内存空间可以是不连续的,通过指针来进行数据的访问,这个特点使得它的随即存取变的非常没有效率,因此它没有提供[]操作符的重载。但由于链表的特点,它可以以很好的效率支持任意地方的删除和插入。

    deque是一个double-ended queue,它的具体实现不太清楚,但知道它具有以下两个特点:
    它支持[]操作符,也就是支持随即存取,并且和vector的效率相差无几,它支持在两端的操作:push_back,push_front,pop_back,pop_front等,并且在两端操作上与list的效率也差不多。

    因此在实际使用时,如何选择这三个容器中哪一个,应根据你的需要而定,一般应遵循下面
    的原则:
      1、如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector
      2、如果你需要大量的插入和删除,而不关心随即存取,则应使用list
      3、如果你需要随即存取,而且关心两端数据的插入和删除,则应使用deque。

     

     

    vector为存储的对象分配一块连续的地址空间,因此对vector中的元素随机访问效率很高。在vecotor中插入或者删除某个元素,需要将现有元素进行复制,移动。如果vector中存储的对象很大,或者构造函数复杂,则在对现有元素进行拷贝时开销较大,因为拷贝对象要调用拷贝构造函数。对于简单的小对象,vector的效率优于list。vector在每次扩张容量的时候,将容量扩展2倍,这样对于小对象来说,效率是很高的。

    list中的对象是离散存储的,随机访问某个元素需要遍历list。在list中插入元素,尤其是在首尾插入元素,效率很高,只需要改变元素的指针。

    综上所述:

    vector适用:对象数量变化少,简单对象,随机访问元素频繁

    list适用:对象数量变化大,对象复杂,插入和删除频】

    展开全文
  • 微软vs stl中vector和list的效率比较

    千次阅读 2017-08-17 18:33:08
    按照理解,链表(list)的插入删除时间空间开销应该比顺序表(vector)的效率更高。考虑删除操作,由于vector删除的时候,会存在内存拷贝,所以时间空间效率开销肯定较之于list大,这个毫无疑问。但是令我始料不及...
  • list和map: 使用erase()函数时直接将迭代器作为实参传入,但这时erase()函数是有返回值的,删除要销毁的元素的指针,并且返回下一个元素的指针,所以要这样来写: itor = List.erase( itor );map同理。 ...
  • 直接上结论: (1)在release模式(O3)下,vector比...而list容器一般有头尾指针,遍历时需要跳转,内存分布不连接, cache miss机率大。但为什么debug模式下vectorlist快,暂时不能解释,谁能回答一下万分感谢。...
  • 一般的正向集合遍历 1. for/index/size模式 for(int i = 0; i < collection.size(); ++i) { std::cout << collection[i] << std::endl; } 弊端: 只适合std::vector这种可以通过下标随机O(1)时间...
  • list<int>::iterator iter_list = list_my.begin(); for(iter_list;iter_list!=list_my.end();){ if(*iter_list==2){ list_my.erase(iter_list++); 或者 // iter_list=list_my.erase(iter_list); ...
  • stl vector/list如何一边遍历一边删除

    千次阅读 2012-11-01 12:51:52
    有时候我们在遍历stl的容器的时候需要删除一些不符合条件的item,这时候我们就要担心iterator...下面比较一下list vector的两种一边遍历一边删除: // list list lll; // vector // vector lll; lll.push_ba
  • 论C++11 中vector的N种遍历方法

    千次阅读 2019-11-12 13:33:43
    vector是经常要使用到的std组件,对于vector遍历,本文罗列了若干种写法。(注:本文中代码为C++11标准的代码,需要在较新的编译器中编译运行) 假设有这样一个vector:(注意,这种列表初始化的方法是c++11中...
  • #include <bits/stdc++.h> using namespace std; inline void myprint(int val) { cout << val << " "; } #define mode4 ... vector<int> v; for (int i = 0; i < 9999; i++)
  • C++ vector的N种遍历方法

    千次阅读 2019-04-17 14:33:15
    vector是经常要使用到的std组件,对于vector遍历,本文罗列了若干种写法。 (注:本文中代码为C++11标准的代码,需要在较新的编译器中编译运行) 假设有这样的一个vector:(注意,这种列表初始化的方法是c++...
  • Java Vector遍历的五种方法

    万次阅读 2015-08-06 09:52:14
    Java Vector遍历的五种方法 ------------------------------------------------------------------------------------------------- package list; import java.util.Enumeration; import java.util.Iterator...
  • list set vector map 遍历方式总结
  • Vector遍历

    2019-06-12 15:05:17
    通过迭代器遍历。即通过Iterator去遍历。 Integer value = null; int size = vec.size(); for (int i=0; i<... value = (Integer)vec.get(i);...由于Vector实现了RandomAccess接口,它支持通过索引值去随机...
  • 在容器遍历过程中怎样动态地删除满足条件的元素,而不影响容器本次的遍历过程
  • 今天我发现一个被骗好多年的事情,直接看... std::vector<int> vec; vec.push_back(1); vec.push_back(2); for(auto it=vec.begin();it!=vec.end();) { if(*it==1) { vec.erase(it++); } else { it++; }
  • 在我们开发过程中常常会用到STD中的一些容器,容器的使用无非就是增删修查等操作,今天要说的是关于STD中常用容器vector/list/map遍历条件删除元素的问题。 我们知道直接遍历容器的所有元素很简单,直接for循环就...
  • vector void fun(int& p) { p = 8; } int main() { vector<int> list; list.push_back(0); list.push_back(1); //向量元素值被修改 for (int i=0;i<list.size();i++) { fun(list[i]); } //...
  • 图的实现有两种方法,一种是邻接矩阵,另一种是邻接表,这两种实现各有各的优缺点,以下给出了邻接表的实现并且DFS遍历的代码实现。 举例 // A simple representation of graph using STL #include<iostream>...
  • std vector与std list的效率比较

    千次阅读 2016-11-05 17:36:39
    于是做了一个简单的测试,对std vector和list的push_back与遍历操作的效率进行比较。 结果如下: 1. push_back操作:连续push_back操作100000个元素,然后clear()。一直重复10000次。 vector耗时13s, list...
  • 下面小编就为大家带来一篇vector, list, map在遍历时删除符合条件的元素实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • vector和list的区别&&添加迭代器

    千次阅读 2019-11-12 12:06:30
    如何给一个容器增加迭代器? 第一步 给迭代器 封装一个类 1构造 类中实现什么方法就要看使用的时候需要什么。 一般情况下像向着指针方向想...operator ++ operator–(这两个视情况而定,就向for_ward list 单链表(...
  • c++ 容器及list遍历

    千次阅读 2019-07-03 01:39:34
    #include <iostream> #include <...vector> #include <deque> #include <list> #define MAXSIZE 20 //顺序表的最大长度 using namespace std; int main() ...
  • List逆向遍历、反向遍历--Iterator详解

    万次阅读 2017-12-26 20:26:58
    但是java集合中还有一个迭代器ListIterator,在使用List、ArrayList、LinkedList和Vector的时候可以使用。这两种迭代器有什么区别呢?下面我们详细分析。这里有一点需要明确的时候,迭代器指向的位置是元素之前的位置...
  • 对随机访问的速度很慢(需要遍历整个链表),插入数据很快(不需要拷贝移动数据,只需改变指针的指向)。 新添加的元素,list可以任意加入。 vector 封装数组,使用连续内存存储,支持[]运算符。 对随机访问的速度...
  • vector和list最大区别就是存储结构不一样,vector是连续存储结构而list是非连续存储结构。 连续存储结构:vector是可以实现动态增长的对象数组,支持对数组的高效率访问在数组尾端的删除插入操作,在中间头部...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 91,369
精华内容 36,547
关键字:

vector和list遍历