STL序列容器详解之list

最新推荐文章于 2023-02-11 21:38:51 发布
最新推荐文章于 2023-02-11 21:38:51 发布
阅读量202 收藏
点赞数
分类专栏： C++基础 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andyjkt/article/details/116271020
版权

参考链接

list 容器

又称双向链表容器，即该容器的底层是以双向链表的形式实现的。这意味着，list 容器中的元素可以分散存储在内存空间里，而不是必须存储在一整块连续的内存空间中。
在这里插入图片描述
list 容器中各个元素的前后顺序是靠指针来维系的，每个元素都配备了 2 个指针，分别指向它的前一个元素和后一个元素。其中第一个元素的前向指针总为 null，因为它前面没有元素；同样，尾部元素的后向指针也总为 null。

list 容器可以在序列已知的任何位置快速插入或删除元素（时间复杂度为O(1)）。并且在 list 容器中移动元素，也比其它容器的效率高。

使用 list 容器的缺点是，它不能像 array 和 vector 那样，通过位置直接访问元素。

list 容器以模板类list<T>（T 为存储元素的类型）的形式在<list>头文件中，并位于 std 命名空间中。

#include <list>
using namespace std;

list容器的创建

  • 创建一个没有任何元素的空 list 容器：

    std::list<int> values;

  • 创建一个包含 n 个元素的 list 容器：

    std::list<int> values(10);

  • 创建一个包含 n 个元素的 list 容器，并为每个元素指定初始值。

    std::list<int> values(10, 5);

  • 在已有 list 容器的情况下，通过拷贝该容器可以创建新的 list 容器。

    std::list<int> value1(10);
std::list<int> value2(value1);

  • 通过拷贝其他类型容器（或者普通数组）中指定区域内的元素，可以创建新的 list 容器。

    //拷贝普通数组，创建list容器
int a[] = { 1,2,3,4,5 };
std::list<int> values(a, a+5);
//拷贝其它类型的容器，创建 list 容器
std::array<int, 5>arr{ 11,12,13,14,15 };
std::list<int>values(arr.begin()+2, arr.end());//拷贝arr容器中的{13,14,15}

list容器的成员函数

成员函数功能
begin()返回指向容器中第一个元素的双向迭代器。
end()返回指向容器中最后一个元素所在位置的下一个位置的双向迭代器。
rbegin()返回指向最后一个元素的反向双向迭代器。
rend()返回指向第一个元素所在位置前一个位置的反向双向迭代器。
cbegin()和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
cend()和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crbegin()和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crend()和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
empty()判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。
size()返回当前容器实际包含的元素个数。
max_size()返回容器所能包含元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。
front()返回第一个元素的引用。
back()返回最后一个元素的引用。
assign()用新元素替换容器中原有内容。
emplace_front()在容器头部生成一个元素。该函数和 push_front() 的功能相同，但效率更高。
push_front()在容器头部插入一个元素。
pop_front()删除容器头部的一个元素。
emplace_back()在容器尾部直接生成一个元素。该函数和 push_back() 的功能相同，但效率更高。
push_back()在容器尾部插入一个元素。
pop_back()删除容器尾部的一个元素。
emplace()在容器中的指定位置插入元素。该函数和 insert() 功能相同，但效率更高。
insert()在容器中的指定位置插入元素。
erase()删除容器中一个或某区域内的元素。
swap()交换两个容器中的元素，必须保证这两个容器中存储的元素类型是相同的。
resize()调整容器的大小。
clear()删除容器存储的所有元素。
splice()将一个 list 容器中的元素插入到另一个容器的指定位置。
remove(val)删除容器中所有等于 val 的元素。
remove_if()删除容器中满足条件的元素。
unique()删除容器中相邻的重复元素，只保留一个。
merge()合并两个事先已排好序的 list 容器，并且合并之后的 list 容器依然是有序的。
sort()通过更改容器中元素的位置，将它们进行排序。
reverse()反转容器中元素的顺序。
#include <iostream>
#include <list>
using namespace std;
int main()
{
    //创建空的 list 容器
    std::list<double> values;
    //向容器中添加元素
    values.push_back(3.1);
    values.push_back(2.2);
    values.push_back(2.9);
    cout << "values size：" << values.size() << endl;
    //对容器中的元素进行排序
    values.sort();
    //使用迭代器输出list容器中的元素
    for (std::list<double>::iterator it = values.begin(); it != values.end(); ++it) {
        std::cout << *it << " ";
    }
    return 0;
}

list迭代器及用法

list 容器迭代器最大的不同在于，其配备的迭代器类型为双向迭代器，而不再是随机访问迭代器。
这意味着，假设 p1 和 p2 都是双向迭代器，则它们支持使用 ++p1、 p1++、 p1–、 p1++、 *p1、 p1==p2 以及 p1!=p2 运算符，但不支持以下操作（其中 i 为整数）：

  • p1[i]：不能通过下标访问 list 容器中指定位置处的元素。
  • p1-=i、 p1+=i、 p1+i 、p1-i：双向迭代器 p1 不支持使用 -=、+=、+、- 运算符。
  • p1<p2、 p1>p2、 p1<=p2、 p1>=p2：双向迭代器 p1、p2 不支持使用 <、 >、 <=、 >= 比较运算符。
#include <iostream>
#include <list>
using namespace std;
int main()
{
    //创建 list 容器
    std::list<char> values{'h','t','t','p',':','/','/','c','.','b','i','a','n','c','h','e','n','g','.','n','e','t'};
    //使用begin()/end()迭代器函数对输出list容器中的元素
    for (std::list<char>::iterator it = values.begin(); it != values.end(); ++it) {
        std::cout << *it;
    }
    cout << endl;
    //使用 rbegin()/rend()迭代器函数输出 lsit 容器中的元素
    for (std::list<char>::reverse_iterator it = values.rbegin(); it != values.rend();++it) {
        std::cout << *it;
    }
    return 0;
}

程序中比较迭代器之间的关系，用的是 != 运算符，因为它不支持 < 等运算符。另外在实际场景中，所有迭代器函数的返回值都可以传给使用 auto 关键字定义的变量，因为编译器可以自行判断出该迭代器的类型。

list 容器在进行插入（insert()）、接合（splice()）等操作时，都不会造成原有的 list 迭代器失效，甚至进行删除操作，而只有指向被删除元素的迭代器失效，其他迭代器不受任何影响。

#include <iostream>
#include <list>
using namespace std;
int main()
{
    //创建 list 容器
    std::list<char> values{'h','t','t','p',':','/','/','c','.','b','i','a','n','c','h','e','n','g','.','n','e','t'};
    //创建 begin 和 end 迭代器
    std::list<char>::iterator begin = values.begin();
    std::list<char>::iterator end = values.end();
    //头部和尾部插入字符 '1'
    values.insert(begin, '1');
    values.insert(end, '1');
    while (begin != end)
    {
        std::cout << *begin;
        ++begin;
    }
    return 0;
}

访问元素的几种方法

list 容器不支持随机访问，未提供下标操作符 [] 和 at() 成员函数，也没有提供 data() 成员函数。

front() 和 back()

#include <iostream>
#include <list>
using namespace std;
int main()
{
    std::list<int> mylist{ 1,2,3,4 };
    int &first = mylist.front();
    int &last = mylist.back();
    cout << first << " " << last << endl;
    first = 10;
    last = 20;
    cout << mylist.front() << " " << mylist.back() << endl;
    return 0;
}

使用 list 容器的迭代器

#include <iostream>
#include <list>
using namespace std;
int main()
{
    const std::list<int> mylist{1,2,3,4,5};
    auto it = mylist.begin();
    cout << *it << " ";
    ++it;
    while (it!=mylist.end())
    {
        cout << *it << " ";
        ++it;  
    }
    return 0;
}

list添加（插入）元素方法

#include <iostream>
#include <list>
using namespace std;
int main()
{
    std::list<int> values{1,2,3};
    values.push_front(0);//{0,1,2,3}
    values.push_back(4); //{0,1,2,3,4}
    values.emplace_front(-1);//{-1,0,1,2,3,4}
    values.emplace_back(5);  //{-1,0,1,2,3,4,5}
   
    //emplace(pos,value),其中 pos 表示指明位置的迭代器，value为要插入的元素值
    values.emplace(values.end(), 6);//{-1,0,1,2,3,4,5,6}
    for (auto p = values.begin(); p != values.end(); ++p) {
        cout << *p << " ";
    }
    return 0;
}

insert()成员方法

#include <iostream>
#include <list>
#include <array>
using namespace std;
int main()
{
    std::list<int> values{ 1,2 };
    //第一种格式用法
    values.insert(values.begin() , 3);//{3,1,2}
    //第二种格式用法
    values.insert(values.end(), 2, 5);//{3,1,2,5,5}
    //第三种格式用法
    std::array<int, 3>test{ 7,8,9 };
    values.insert(values.end(), test.begin(), test.end());//{3,1,2,5,5,7,8,9}
    //第四种格式用法
    values.insert(values.end(), { 10,11 });//{3,1,2,5,5,7,8,9,10,11}
    for (auto p = values.begin(); p != values.end(); ++p)
    {
        cout << *p << " ";
    }
    return 0;
}

splice()成员方法

和 insert() 成员方法相比，splice() 成员方法的作用对象是其它 list 容器，其功能是将其它 list 容器中的元素添加到当前 list 容器中指定位置处。

list 容器底层使用的是链表存储结构，splice() 成员方法移动元素的方式是，将存储该元素的节点从 list 容器底层的链表中摘除，然后再链接到当前 list 容器底层的链表中。这意味着，当使用 splice() 成员方法将 x 容器中的元素添加到当前容器的同时，该元素会从 x 容器中删除。

#include <iostream>
#include <list>
using namespace std;
int main()
{
    //创建并初始化 2 个 list 容器
    list<int> mylist1{ 1,2,3,4 }, mylist2{10,20,30};
    list<int>::iterator it = ++mylist1.begin(); //指向 mylist1 容器中的元素 2
   
    //调用第一种语法格式
    mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
                                 // mylist2:
                                 // it 迭代器仍然指向元素 2，只不过容器变为了 mylist1
    //调用第二种语法格式，将 it 指向的元素 2 移动到 mylist2.begin() 位置处
    mylist2.splice(mylist2.begin(), mylist1, it);   // mylist1: 1 10 20 30 3 4
                                                    // mylist2: 2
                                                    // it 仍然指向元素 2
   
    //调用第三种语法格式，将 [mylist1.begin(),mylist1.end())范围内的元素移动到 mylist.begin() 位置处                  
    mylist2.splice(mylist2.begin(), mylist1, mylist1.begin(), mylist1.end());//mylist1:
                                                                             //mylist2:1 10 20 30 3 4 2
   
    cout << "mylist1 包含 " << mylist1.size() << "个元素" << endl;
    cout << "mylist2 包含 " << mylist2.size() << "个元素" << endl;
    //输出 mylist2 容器中存储的数据
    cout << "mylist2:";
    for (auto iter = mylist2.begin(); iter != mylist2.end(); ++iter) {
        cout << *iter << " ";
    }
    return 0;
}

list删除元素

pop_front()、pop_back() 和 clear() 的用法非常简单，这里仅给出一个样例

#include <iostream>
#include <list>
using namespace std;
int main()
{
    list<int>values{ 1,2,3,4 };
   
    //删除当前容器中首个元素
    values.pop_front();//{2,3,4}
   
    //删除当前容器最后一个元素
    values.pop_back();//{2,3}
   
    //清空容器，删除容器中所有的元素
    values.clear(); //{}
   
    for (auto begin = values.begin(); begin != values.end(); ++begin)
    {
        cout << *begin << " ";
    }
    return 0;
}

erase() 成员函数

#include <iostream>
#include <list>
using namespace std;
int main()
{
    list<int>values{ 1,2,3,4,5 };
    //指向元素 1 的迭代器
    auto del = values.begin();
    //迭代器右移，改为指向元素 2
    ++del;
    values.erase(del); //{1,3,4,5}
    for (auto begin = values.begin(); begin != values.end(); ++begin)
    {
        cout << *begin << " ";
    }
    return 0;
}

#include <iostream>
#include <list>
using namespace std;
int main()
{
    list<int>values{ 1,2,3,4,5 };
    //指定删除区域的左边界
    auto first = values.begin();
    ++first;//指向元素 2
    //指向删除区域的右边界
    auto last = values.end();
    --last;//指向元素 5
    //删除 2、3 和 4
    values.erase(first, last);
    for (auto begin = values.begin(); begin != values.end(); ++begin)
    {
        cout << *begin << " ";
    }
    return 0;
}

remove() 成员函数

#include <iostream>
#include <list>
using namespace std;
int main()
{
    list<char>values{'a','b','c','d'};
    values.remove('c');
    for (auto begin = values.begin(); begin != values.end(); ++begin)
    {
        cout << *begin << " ";
    }
    return 0;
}

unique() 函数

#include <iostream>
#include <list>
using namespace std;
//二元谓词函数
bool demo(double first, double second)
{
    return (int(first) == int(second));
}
int main()
{
    list<double> mylist{ 1,1.2,1.2,3,4,4.5,4.6 };
    //删除相邻重复的元素，仅保留一份
    mylist.unique();//{1, 1.2, 3, 4, 4.5, 4.6}
    for (auto it = mylist.begin(); it != mylist.end(); ++it)
        cout << *it << ' ';
    cout << endl;
    //demo 为二元谓词函数，是我们自定义的去重规则
    mylist.unique(demo);
    for (auto it = mylist.begin(); it != mylist.end(); ++it)
        std::cout << *it << ' ';
    return 0;
}

通过将自定义的谓词函数（不限定参数个数）传给 remove_if() 成员函数，list 容器中能使谓词函数成立的元素都会被删除.

#include <iostream>
#include <list>
using namespace std;
int main()
{
    std::list<int> mylist{ 15, 36, 7, 17, 20, 39, 4, 1 };
    //删除 mylist 容器中能够使 lamba 表达式成立的所有元素。
    mylist.remove_if([](int value) {return (value < 10); }); //{15 36 17 20 39}
    for (auto it = mylist.begin(); it != mylist.end(); ++it)
        std::cout << ' ' << *it;
    return 0;
}

forward_list容器

其底层实现和 list 容器一样，采用的也是链表结构，只不过 forward_list 使用的是单链表，而 list 使用的是双向链表.

forward_list 容器只提供前向迭代器，而不是双向迭代器。这意味着，forward_list 容器不具有 rbegin()、rend() 之类的成员函数。

forward_list 容器有什么存在的必要呢？
存储相同个数的同类型元素，单链表耗用的内存空间更少，空间利用率更高，并且对于实现某些操作单链表的执行效率也更高。

效率高是选用 forward_list 而弃用 list 容器最主要的原因，换句话说，只要是 list 容器和 forward_list 容器都能实现的操作，应优先选择 forward_list 容器。

forward_list容器的创建

#include <forward_list>
using namespace std;

  • 创建一个没有任何元素的空 forward_list 容器:

    std::forward_list<int> values;

  • 创建一个包含 n 个元素的 forward_list 容器：

    std::forward_list<int> values(10);

  • 创建一个包含 n 个元素的 forward_list 容器，并为每个元素指定初始值。

    std::forward_list<int> values(10, 5);

  • 在已有 forward_list 容器的情况下，通过拷贝该容器可以创建新的 forward_list 容器。

    std::forward_list<int> value1(10);
std::forward_list<int> value2(value1);

  • 通过拷贝其他类型容器（或者普通数组）中指定区域内的元素，可以创建新的 forward_list 容器。

    //拷贝普通数组，创建forward_list容器
int a[] = { 1,2,3,4,5 };
std::forward_list<int> values(a, a+5);
//拷贝其它类型的容器，创建forward_list容器
std::array<int, 5>arr{ 11,12,13,14,15 };
std::forward_list<int>values(arr.begin()+2, arr.end());//拷贝arr容器中的{13,14,15}

forward_list容器的成员函数

成员函数功能
before_begin()返回一个前向迭代器，其指向容器中第一个元素之前的位置。
begin()返回一个前向迭代器，其指向容器中第一个元素的位置。
end()返回一个前向迭代器，其指向容器中最后一个元素之后的位置。
cbefore_begin()和 before_begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
cbegin()和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
cend()和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
empty()判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。
max_size()返回容器所能包含元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。
front()返回第一个元素的引用。
assign()用新元素替换容器中原有内容。
push_front()在容器头部插入一个元素。
emplace_front()在容器头部生成一个元素。该函数和 push_front() 的功能相同，但效率更高。
pop_front()删除容器头部的一个元素。
emplace_after()在指定位置之后插入一个新元素，并返回一个指向新元素的迭代器。和 insert_after() 的功能相同，但效率更高。
insert_after()在指定位置之后插入一个新元素，并返回一个指向新元素的迭代器。
erase_after()删除容器中某个指定位置或区域内的所有元素。
swap()交换两个容器中的元素，必须保证这两个容器中存储的元素类型是相同的。
resize()调整容器的大小。
clear()删除容器存储的所有元素。
splice_after()将某个 forward_list 容器中指定位置或区域内的元素插入到另一个容器的指定位置之后。
remove(val)删除容器中所有等于 val 的元素。
remove_if()删除容器中满足条件的元素。
unique()删除容器中相邻的重复元素，只保留一个。
merge()合并两个事先已排好序的 forward_list 容器，并且合并之后的 forward_list 容器依然是有序的。
sort()通过更改容器中元素的位置，将它们进行排序。
reverse()反转容器中元素的顺序。
#include <iostream>
#include <forward_list>
using namespace std;
int main()
{
    std::forward_list<int> values{1,2,3};
    values.emplace_front(4);//{4,1,2,3}
    values.emplace_after(values.before_begin(), 5); //{5,4,1,2,3}
    values.reverse();//{3,2,1,4,5}
    for (auto it = values.begin(); it != values.end(); ++it) {
        cout << *it << " ";
    }
    return 0;
}

distance()函数

forward_list 容器中是不提供 size() 函数的，但如果想要获取 forward_list 容器中存储元素的个数，可以使用头文件 <iterator> 中的distance() 函数。

#include <iostream>
#include <forward_list>
#include <iterator>
using namespace std;
int main()
{
    std::forward_list<int> my_words{1,2,3,4};
    int count = std::distance(std::begin(my_words), std::end(my_words));
    cout << count;
    return 0;
}

advance() 函数

forward_list 容器迭代器的移动除了使用 ++ 运算符单步移动，还能使用 advance() 函数

#include <iostream>
#include <forward_list>
using namespace std;
int main()
{
    std::forward_list<int> values{1,2,3,4};
    auto it = values.begin();
    advance(it, 2);
    while (it!=values.end())
    {
        cout << *it << " ";
        ++it;
    }
    return 0;
}
C++中STL各容器详解
king_weng的博客
03-09 7256
一、STL中六大组件： 1）容器（Container），是一种数据结构，如list，vector，和deques ，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器； 2）迭代器（Iterator），提供了访问容器中对象的方法。例如，可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以...
STL 上头系列——list 容器详解
qq_61500888的博客
07-25 6190
带你一命通关 list 容器 十分钟手撕 STL 底层原理
STL——list
最新发布
m0_63020222的博客
02-11 848
C++STL：list常用接口介绍、list和vector的区别、模拟实现list
stl源码剖析04——list
www_dong的博客
02-18 142
一、list概述 list的使用语法：https://blog.csdn.net/qq_41453285/article/details/105483054 总的来说：环形双向链表 特点： 底层是使用链表实现的，支持双向顺序访问 在list中任何位置进行插入和删除的速度都很快 不支持随机访问，为了访问一个元素，必须遍历整个容器 与其他容器相比，额外内存开销大 设计目的：令容器在任何位置进行插入和删除都很快 何时使用： 容器需要不断地在中间插入或删除元素 无论删除还是增加，l
vector中erase用法注意事项
weixin_34130269的博客
11-12 138
vector::erase()：从指定容器删除指定位置的元素或某段范围内的元素vector::erase()方法有两种重载形式如下：iteratorerase(iterator_Where); iteratorerase(iterator_First,iterator_Last);如果是删除指定位置的元素时：返回值是一个迭代器，指向删除元素下一个元...
在linux环境下，使用erase删除vector元素注意事项，删除的元素居然自动存放在改队列末尾
学无止尽，谨言慎行！
07-02 704
工作8年，第一次遇到这种问题，百思不得其解，使用erase删除vector元素，删除正常，但后面打印数据发现，元素居然依然存在。当然其实最终发现原因也是不注意代码细节引起的。先上代码。 注：以下代码在windows环境直接报错，而linux居然正常输出。 #include <iostream> #include <vector> using namespace std; int main() { std::vector<int> vec; for (int i =
vector.erase()函数的常见陷阱
merenguesl的博客
08-02 1306
对 vector 尾部进行插入和删除操作可以很方便地通过 vector.push_back() 和 vector.pop_back() 函数来进行。 但是想要对中间部分的数据进行增删操作，就需要使用到迭代器。 为了对迭代器的使用进行学习，我们先定义一个整形数组v，并且给他赋初值: vector<int> v = { 10,20,30,40,50,60,70 }; 接下来，我们给数组插入5个1000,并且尝试使用迭代器将5个1000全部删除： v.insert(v.begin(),
STL序列容器详解：共性与操作
序列式容器是C++标准模板库(STL)中的重要组成部分，包括vector、deque和list等。这些容器共享一系列特性，使得它们在处理线性数据结构时具有高度的灵活性和效率。以下是序列式容器的主要共性： 1. **构造函数**： ...
C++ STL：序列容器详解与抽象应用
STL序列容器是C++编程的强大工具，它们结合了高效的数据结构和算法，使得程序员能够更加优雅地处理复杂的数据操作，提升了代码的模块化和复用性。同时，STL的抽象概念，特别是参数化和规格化抽象，为开发者提供了...
STL list容器详解：双向链表的高效操作
"STL中的list容器是一种序列式容器，其功能类似于数据结构中的双向链表，具有在链表任何位置快速插入和删除的优势。list的每个节点包含前驱元素指针、数据域和后继元素指针。list形成一个双向循环链，不支持快速随机...
问题总结
Bourne的博客
12-06 239
问题总结 1.if-else问题 如果下面这个else if改成if，那么就会变成后面两个if-else配对，那么最左侧特判结束后还会进入这个判断导致边界溢出出错 2.STL中erase导致指针失效的问题 删除不是n的元素,注意删除后it的位置被破坏不能++操作,我们在删除前要先保存 ​ for (auto it=pos.begin(); it!=pos.end();it++) ​ if (ans[*it].dp != n) ​ { ​ auto t
C++STL之vecot、list、deque的排序插入访问效率
zidian666的博客
01-20 711
低数据量的参考价值不高，其余数据仅供参考，测试代码在末尾 排序 第一次测试 第二次测试 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++中map结构erase函数不同用法的效率差异
weixin_39703605的博客
01-11 1887
这篇博客对c++中map结构erase函数的不同用法进行效率对比测试。内附可编译通过的例程。
stl之链表List
IOT_SHUN的博客
03-15 788
C++ Lists（链表）Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢. 说起这个访问速率呢？给大家举个很简单的例子向量(vectors)       也就是顺序表，它的存储方法就类似于c语言的数组，那么数组可以通过下标来访问，所以效率快而用向量表存储数据，假如需要大量地插入，删除数据，效率就很慢了，为什么呢？原因    如图...
c++STL中的List容器详解
qq_45569601的博客
02-27 560
c++STL中的List容器详解 一、提要 List 是一个双向链表容器，List容器能够在任何地方快速的删除添加元素。 List 容器的接口与其他容器的接口相似，List容器不能随机数据存取元素（如：用下标或者用at.()方法都是不可以的），数据存取我有必要提一下，因为我以前也搞不懂，我今天问了老师才知道，数据存就是把数据存进去，修改它的值，取就是把数据取出来，这里存的什么值，使用迭代器时可以进...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值