c++ list容器

list容器就是一个双向链表,可以高效地进行插入删除元素。

构造函数

   list<int> c0; //空链表

  list<int> c1(3); //建一个含三个默认值是0的元素的链表

  list<int> c2(5,2); //建一个含五个元素的链表,值都是2

  list<int> c4(c2); //建一个c2的copy链表

  list<int> c5(c1.begin(),c1.end()); //c5含c1一个区域的元素[_First, _Last)。

成员函数

c.begin()      返回指向链表第一个元素的迭代器。

c.end()      返回指向链表最后一个元素之后的迭代器。

c.rbegin()      返回逆向链表的第一个元素,即c链表的最后一个数据。

c.rend()      返回逆向链表的最后一个元素的下一个位置,即c链表的第一个数据再往前的位置。

c.empty()  判断链表是否为空。

c.size()      返回链表c中实际元素的个数。

c.max_size() 
    返回链表c可能容纳的最大元素数量。

c.clear() 
    清除链表c中的所有元素。

operator=      重载赋值运算符。

     int num[]={1,2,3,4,5};
     list<int> a1(num,num+5),a2;
     a2 = a1;

c.front()      返回链表c的第一个元素。

c.back()      返回链表c的最后一个元素。

     <span style="font-family: verdana, arial, helvetica, sans-serif;">int num[]={1,2,3,4,5};</span><pre name="code" class="cpp" style="color: rgb(0, 0, 102); font-size: 13px; line-height: 19px;">     list<int> a1(num,num+5)

if(!a1.empty()){ cout << "the first number is:" << a1.front() << endl; cout << "the last number is:" << a1.back() << endl; }


c.insert(pos,num)      在pos位置插入元素num。

c.insert(pos,n,num)      在pos位置插入n个元素num。

c.insert(pos,beg,end)      在pos位置插入区间为[beg,end)的元素。

c.erase(pos)    删除pos位置的元素。

c.push_back(num)      在末尾增加一个元素。

c.pop_back()      删除末尾的元素。

c.push_front(num)      在开始位置增加一个元素。

c.pop_front()      删除第一个元素。

resize(n)      从新定义链表的长度,超出原始长度的部分用0代替,小于原始部分删除。

resize(n,num)            从新定义链表的长度,超出原始长度的部分用num代替。

c1.swap(c2);      将c1和c2交换。

swap(c1,c2);      同上。

int main()
{
    int num[]={1,2,3,4,5};
    list<int> a1(num,num+5),a2(6,10);
    a2.swap(a1);
    list<int>::iterator it;
    cout << "after swap a2=:";
    for(it = a2.begin();it!=a2.end();it++){
        cout << *it << " ";
    }
    cout << endl;
    cout << "after swap a1=:";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    return 0;
}

执行结果:

c1.merge(c2)      合并2个有序的链表并使之有序,从新放到c1里,释放c2。

c1.merge(c2,comp)      合并2个有序的链表并使之按照自定义规则排序之后从新放到c1中,释放c2。

    int num1[]={1,2,3},num2[]={4,5,6};
    list<int> a1(num1,num1+3),a2(num2,num2+3);
    a1.merge(a2);
    list<int>::iterator it;
    cout << "a1.merge(a2):";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;

c1.splice(c1.beg,c2)      将c2连接在c1的beg位置,释放c2

    int num1[]={1,2,3},num2[]={4,5,6};
    list<int> a1(num1,num1+3),a2(num2,num2+3);
    a1.splice(a1.begin(), a2);           //此时的beg是开端位置
    list<int>::iterator it;
    cout << "a1.splice(a1.begin(),a2):";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;

c1.splice(c1.beg,c2,c2.beg)      将c2的beg位置的元素连接到c1的beg位置,并且在c2中施放掉beg位置的元素

int main()
{
    int num1[]={1,2,3},num2[]={4,5,6};
    list<int> a1(num1,num1+3),a2(num2,num2+3);
    a1.splice(a1.begin(), a2,++a2.begin());
    list<int>::iterator it;
    cout << "a1:";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
     }
    cout <<endl<<"a2:";
    for(it = a2.begin();it!=a2.end();it++){
        cout << *it << " ";
     }
    cout << endl;
    return 0;
}

c1.splice(c1.beg,c2,c2.beg,c2.end)      将c2的[beg,end)位置的元素连接到c1的beg位置并且释放c2的[beg,end)位置的元素。

    int num1[]={1,2,3},num2[]={4,5,6};
    list<int> a1(num1,num1+3),a2(num2,num2+3);
    a1.splice(a1.begin(),a2,a2.begin(),--a2.end());
    list<int>::iterator it;
    cout << "a1:";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout <<endl <<"a2:";
    for(it = a2.begin();it!=a2.end();it++){
        cout << *it << " ";
    }
    cout << endl;
    return 0;

 remove(num)             删除链表中匹配num的元素。( 不是algorithm头文件里面的remove)

int main()
{
    int num1[]={1,2,3,4,5};
    list<int> a1(num1,num1+5);
    a1.remove(3);
    list<int>::iterator it;
    cout << "remove():";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;
}

remove_if(comp)
      删除条件满足的元素,参数为自定义的回调函数。

reverse()
      反转链表

    int num1[]={1,2,3,4,5};
    list<int > a1(num1,num1+5);
    a1.reverse();                    //变成了5,4,3,2,1
    list<int>::iterator it;
    cout << "reverse:";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;

unique()
      删除相邻的元素

    int num1[]={1,2,2,2,2,3,2,4};
    list<int > a1(num1,num1+8);
    a1.unique();
    list<int>::iterator it;
    cout << "unique:";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;
    return 0;

c.sort()       将链表排序,默认升序             //不是algorithm头文件里面的sort,是成员函数

c.sort(comp)       自定义回调函数实现自定义排序

int main()
{
    int num1[]={1,3,2,5,4};
    list<int > a1(num1,num1+5);
    a1.sort();               //变成了1,2,3,4,5
    list<int>::iterator it;
    cout << "sort():";
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;
}

c.assign(n,num)      将n个num拷贝赋值给链表c。

c.assign(beg,end)      将[beg,end)区间的元素拷贝赋值给链表c。

int main()
{
    int a[5] = {1,2,3,4,5};
    list<int> a1;
    list<int>::iterator it;
    a1.assign(2,10);               //当然构造链表的时候直接<span style="font-family: verdana, arial, helvetica, sans-serif;">list<int> a1(2,10)即可。</span>
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;
    a1.assign(a,a+5);<span style="white-space:pre">		</span>  //<span style="font-family: verdana, arial, helvetica, sans-serif;">当然构造链表的时候直接</span><span style="font-family: verdana, arial, helvetica, sans-serif;">list<int> a1(a,a+5)即可。</span>
    for(it = a1.begin();it!=a1.end();it++){
        cout << *it << " ";
    }
    cout << endl;
}

重载运算符

operator==

operator!=

operator<

operator<=

operator>

operator>=

时间: 2024-10-25 03:32:27

c++ list容器的相关文章

Docker学习笔记——Mongo Dockerfile及容器运行

1.创建项目目录mongo,在目录下上传下载的Mongodb安装文件及mongo.conf配置文件,创建Dockerfile文件,项目结构如下: mongo - Dockerfile - mongo.conf - mongodb-linux-x86_64-3.4.9.tgz - data - logs Dockerfile内容如下: # mongo # SOURCE_IMAGE FROM centos # MAINTAINER_INFO MAINTAINER bluemooder [email 

spring父子容器

通过HierarchicalBeanFactory接口,Spring的IoC容器可以建立父子层级关联的容器体系,子容器可以访问父容器中的Bean,但父容器不能访问子容器的Bean.在容器内,Bean的id必须是唯一的,但子容器可以拥有一个和父容器id相同的Bean.父子容器层级体系增强了Spring容器架构的扩展性和灵活性,因为第三方可以通过编程的方式,为一个已经存在的容器添加一个或多个特殊用途的子容器,以提供一些额外的功能. Spring使用父子容器实现了很多功能,比如在Spring MVC中

java持有对象【2】ArrayList容器续解

此为JDK API1.6.0对ArrayList的解释. ArrayList 使用java泛型创建类很复杂,但是应用预定义的泛型很简单.例如,要想定义用来保存Apple对象的ArrayList,可以声明ArrayList<Apple>,尖括号内为类型参数,(可以为多个).它指定了容器可以保存的类型. 通过使用泛型,可以在编译期防止将错误类型的对象放置到容器中. ArrayList向上转型为List. 应该注意到,在将元素从List中取出时,类型转换不是必须的了.因为List在调用get()时会

width:100%与绝对定位同时存在,偏移出父级容器

当父级容器内的子元素width设为100%,而子元素又有绝对定位时,子元素伸展超出父级容器,像下面 出现这种情况的原因,width:100%,这个百分之百是相对其定位父级而言的,其定位父级有多宽,这个子元素就有多宽,所以子元素跑到了父级容器外 html <div class="container"> <div class="content">好的</div> </div> css .container { positi

【Docker常见问题2】如何设置容器日志大小和保留个数

举例:当tomcat容器的运行,容器占用空间越来越大,约1个月就会超过2G,如何解决? 步骤1:查看容器日志大小:假设容器目录为/var/lib/docker/containers,那么执行如下命令 cd /var/lib/docker/containers  #进入默认容器空间目录 du -sh *            #统计文件大小2.4G  de92a5643f7ffb106f8abba21fc0f93996842917a52879153adc95a73312934a-json.log

Vector容器 和 iteration 迭代器

vector容器 vector是同一种类型的对象的集合,每个对象都有一个对应的整数索引值.和string对象一样,标准库负责管理存储元素的相关内存.我们把vector称为容器,是因为它可以包含其他对象.一个容器中的所有对象都必须是同一种类型的. 使用vector之前,必须包含相应的头文件.#include <vector> using std::vector; vector是一个类模板(class template).模板允许程序员编写单个类或函数定义,这个类和函数定义可用于不同的数据类型上.

架构师养成--7.同步类容器和并发类容器

一.同步类容器 同步类容器都是线程安全的,但在某些场景下可能需要加锁来保护复合操作.复合类操作如:迭代(反复访问元素,遍历完容器中的所有元素).跳转(根据指定的顺序找到当前元素的下一个元素).以及条件运算.这些复合操作在多线程并发的修改容器时,可能会表现出意外的行为,最经典的便是ConcurrentModificationException,原因是当容器迭代的过程中,被并发的修改了内容,这是由于早期迭代器设计的时候并没有考虑并发修改的问题. 同步类容器:如古老的Vector/HashTable.

vector容器用法详解

vector类称作向量类,它实现了动态数组,用于元素数量变化的对象数组.像数组一样,vector类也用从0开始的下标表示元素的位置:但和数组不同的是,当vector对象创建后,数组的元素个数会随着vector对象元素个数的增大和缩小而自动变化. vector类常用的函数如下所示: 1.构造函数 vector():创建一个空vector vector(int nSize):创建一个vector,元素个数为nSize vector(int nSize,const t& t):创建一个vector,元

【Effective Java】8、优先考虑类型安全的异构容器

有的时候我们一个容器只有一个类型或几个类型并不能满足我们的要求,比如set中存放的元素类型都是同一种,map也就指定的两种 这里我们可以将键进行参数化,而不是将容器参数化,也就是我们可以给容器传一个键的类型,然后value用来放对应的实例,这样就可以存放多个不同的类型了 如: package cn.xf.cp.ch02.item29; import java.util.HashMap; import java.util.Map; public class ManyTypeClass { //一个

stl容器区别: vector list deque set map及底层实现

在STL中基本容器有: vector.list.deque.set.map set 和map都是无序的保存元素,只能通过它提供的接口对里面的元素进行访问 set :集合, 用来判断某一个元素是不是在一个组里面,使用的比较少 map :映射,相当于字典 ,把一个值映射成另一个值,如果想创建字典的话使用它好了 底层采用的是树型结构,多数使用平衡二叉树实现 ,查找某一值是常数时间,遍历起来效果也不错, 只是每次插入值的时候,会重新构成底层的平衡二叉树,效率有一定影响. vector.list.dequ