c++提高第三章STL容器之 list容器

最新推荐文章于 2024-07-17 12:19:34 发布

liu嘿嘿

最新推荐文章于 2024-07-17 12:19:34 发布

阅读量73

点赞数

文章标签： c++ visualstudio

本文链接：https://blog.csdn.net/weixin_46432435/article/details/124467882

版权

3.7 list 容器

3.7.1 list 基本概念

功能：将数据进行链式存储

链表(list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list 的优点

采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

链表灵活，但是空间（指针域）和时间（遍历）额外耗费大

List有一个重要的性质，插入操作和删除操作都不会造成苑有list迭代器的失效，这在vector是不成立的

总结： STL中List和vector是两个最常被使用的容器，各有优缺点

3.7.2 list 构造函数

功能描述：

创建list容器

函数原型：

list<T> lst; //list 采用模板类实现，对象的默认构造形式；
list(beg,end); //构造函数将[beg,end]区间中的元素拷贝给本身
list(n,elem); //构造函数将n个elem拷贝给本身
list(const list & lst); //拷贝构造函数

示例：

#include <iostream>
using namespace std;
#include<list>
//遍历
void printList(const list<int> & l)
{
    for (list<int>::const_iterator it=l.begin();it!=l.end();it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}


void test01()
{
//创建容器
    list<int> l1;//默认构造

    //添加数据
    l1.push_back(10);
    l1.push_back(20);
    l1.push_back(30);
    l1.push_back(40);
    l1.push_back(50);

    //遍历容器
    printList(l1);

    //区间方式构造
    list<int>l2(l1.begin(), l1.end());
    printList(l2);

    //拷贝构造
    list<int>l3(l2);
    printList(l3);

    //n个elem
    list<int>l4(4, 1000);
    printList(l4);
}


int main()
{

    test01();

    system("pause");
    return 0;
}

运行结果如图

总结：list构造方式同其他几个STL常用容器，熟练掌握即可

3.7.3 list 赋值和交换

功能描述:

给list容器进行赋值，以及交换list容器

函数原型：

assign(beg,end); //将[beg，end]区间中的数据拷贝赋值给本身
assign(n,elem); //将n个elem拷贝赋值给本身
list& operator = (const list & lst);//重载等号操作符
swap (lst); //将lst与本身的元素互换

示例：

#include <iostream>
using namespace std;
#include<list>

//list容器赋值和交换
void printList(const list<int> & L)
{
    for (list<int>::const_iterator it=L.begin();it!=L.end();it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}



//赋值
void test01()
{
    list<int>L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    L1.push_back(50);

    printList(L1);

    list<int>L2;
    L2 = L1;//operator = 赋值
    printList(L2);

    list<int>L3;
    L3.assign(L2.begin(), L2.end());
    printList(L3);

    list<int>L4;
    L4.assign(10, 1000);
    printList(L4);
}

//交换
void test02()
{
    list<int>L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    L1.push_back(50);

    list<int> L2;
    L2.assign(10, 100);
     
    cout << "交换前：" << endl;
    printList(L1);
    printList(L2);

    L1.swap(L2);
    cout << "交换后" << endl;
    printList(L1);
    printList(L2);
}



int main()
{

    
    test01();
    test02();
    system("pause");
    return 0;
}

效果图：

总结：

list赋值和交换操作能够灵活应用即可。

3.7.4 list 大小操作

功能描述：

对list容器的大小进行操作

函数原型：

empty(); //判断容器是否为空
size(); //返回容器中元素的个数
resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除
resize(num,elem) ； //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。若容器变短，则末尾超出容器长度的元素被删除

示例：

#include <iostream>
using namespace std;
#include<list>

//list容器大小
void printList(const list<int> & L)
{
    for (list<int>::const_iterator it= L.begin();it!=L.end();it++)
    {
        cout << *it << " ";
    }
    cout << endl;

}





//赋值
void test01()
{
    list<int> L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    L1.push_back(50);
    

    printList(L1);

    //判断容器是否为空
    if (L1.empty())
    {
        cout << "L1为空" << endl;
    }
    else
    {
        cout << "L1不为空" << endl;
        cout << "L1的大小为" << L1.size() << endl;
    }

    //重新指定大小
    L1.resize(10);//
    printList(L1);

    L1.resize(12, 1000);
    printList(L1);

    L1.resize(2);
    printList(L1);


}



int main()
{
    test01();
    
    system("pause");
    return 0;
}

效果图：

总结：

判断是否为空---empty
返回元素个数 ---size
重新指定个数---resize

3.7.5 list 插入和删除

功能描述：

向list容器进行数据的插入和删除

函数原型：

push_back(elem); //在容器尾部插入一个元素
push_front(elem); //在容器头部插入一个元素
pop_back(); //删除容器最后一个元素
pop_front(); //删除容器第一个元素

指定位置操作:

insert(pos ,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos ,n,elem); //在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end); //在pos位置插入[beg，end]区间的数据，无返回值
clear() ; //清空容器所有的数据
erase(beg,end); //删除[beg,end]区间的数据，返回下一个数据的位置
erase(pos); //删除pos位置的数据，返回下一个数据的位置
remove(elem); //删除容器中所有与elem值匹配的元素

示例：

#include <iostream>
using namespace std;
#include<list>

//list 容器插入和删除
/*
* push_back(elem);       //在容器尾部插入一个元素
* push_front(elem);      //在容器头部插入一个元素
* pop_back();               //删除容器最后一个元素
* pop_front();               //删除容器第一个元素

**指定位置操作:**

* insert(pos ,elem);        //在pos位置插入一个elem元素的拷贝，返回新数据的位置
* insert(pos ,n,elem);      //在pos位置插入n个elem数据，无返回值。
* insert(pos,beg,end);      //在pos位置插入[beg，end]区间的数据，无返回值
* clear() ;                              //清空容器所有的数据
* erase(beg,end);                //删除[beg,end]区间的数据，返回下一个数据的位置
* erase(pos);                        //删除pos位置的数据，返回下一个数据的位置
* remove(elem);                 //删除容器中所有与elem值匹配的元素
*/
void printList(const list<int> & L)
{
    for (list<int>::const_iterator it=L.begin();it!=L.end();it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}




void test01()
{
    //尾插
    list<int> L;
    L.push_back(10);
    L.push_back(20);
    L.push_back(30);
    L.push_back(40);
    L.push_back(50);
    //头插
    L.push_front(100);
    L.push_front(200);
    L.push_front(300);
    L.push_front(400);
    L.push_front(500);
    cout << "插入后" << endl;
    printList(L);//500 400 300 200 100 10 20 30 40 50

    //尾删
    cout << "尾删后" << endl;
    L.pop_back();
    printList(L);

    //头删
    cout << "头删后" << endl;
    L.pop_front();
    printList(L);

    //insert插入
    cout << "头部插入666后" << endl;
    L.insert(L.begin(), 666);
    printList(L);

    cout << "第二个位置插入1000后" << endl;
    list<int>::iterator it = L.begin();//不想用L.begin()就得使用迭代器
    L.insert(++it, 1000);
    printList(L);

    //删除
    cout << "删除第一个后" << endl;
    L.erase(L.begin());
    printList(L);

    cout << "删除第二个后" << endl;
    it = L.begin();
    L.erase(++it);
    printList(L);

    //移除
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    cout << "插入10000后" << endl;
    printList(L);
    L.remove(10000);
    cout << "删除与10000值相同的元素后" << endl;
    printList(L);

    //清空
    L.clear();
    cout << "清空后" << endl;
    printList(L);

}



int main()
{
    
    test01();
    system("pause");
    return 0;
}

效果图：

总结：

尾插 ---push_back
尾删 ---pop_back
头插 ---pop_front
头删 --- pop_front
插入 --- insert
删除 --- erase
移除 --- remove
清空 --- clear

3.7.6 list 数据存取

功能描述;

对list容器中数据进行存取

函数原型：

front() ; //返回第一个元素
back(); //返回最后一个元素

示例：

#include <iostream>
using namespace std;
#include<list>

//list 容器 数据存取





void test01()
{
    list<int> L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);

    //L1[0];//不可以用[]访问list容器中的元素
    //L1.at();// 不可以用at方式访问list容器中的元素
    //原因是list本质是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的

    cout << "第一个元素为" << L1.front() << endl;
    cout << "第二个元素为" << L1.back() << endl;

    //验证迭代器是不支持随机访问的
    list<int>::iterator it = L1.begin();
    it++;//支持访问
    it--;
    //it=it+;//不支持随机访问
}


int main()
{
    
    test01();
    system("pause");
    return 0;
}

运行效果图：

总结：

list容器中不可以通过[]或者at方式访问数据
返回第一个元素 ---front
返回最后一个元素 ---back

3.7.7 list 反转和排序

功能描述：

将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse(); //反转链表
sort(); //链表排序

示例：

#include <iostream>
using namespace std;
#include<list>
#include<algorithm>

//容器反转和排序

void printList(const list<int> & L)
{
    for (list<int>::const_iterator it= L.begin();it!=L.end();it++)
    {
        cout << *it << " ";
    } 
    cout<<endl;
}

void test01()
{
    list<int> L1;
    
    L1.push_back(30);
    L1.push_back(20);
    L1.push_back(40);
    L1.push_back(10);
    L1.push_back(50);

    cout << "反转前" << endl;
    printList(L1);

    //反转
    L1.reverse();
    cout << "反转后" << endl;
    printList(L1);
}

bool myCompare(int v1 , int v2)
{
    //降序 就让第一个数大于第二个数
    return v1 > v2;

}

//排序
void test02()
{
    list<int> L1;

    L1.push_back(30);
    L1.push_back(20);
    L1.push_back(40);
    L1.push_back(10);
    L1.push_back(50);

    //排序前
    cout << "排序前：" << endl;
    printList(L1);

    //所有不支持随机访问迭代器的容器，不可以用标准算法
    //不支持随机访问迭代器的容器，内部会提供对应一些算法
    //sort(L1.begin(), L1.end());
    L1.sort();
    cout << "排序后" << endl;//默认排序规则 从小到大 升序
    printList(L1);

    L1.sort(myCompare);//降序方法
    printList(L1);
}
int main()
{
    
    test01();
    test02();
    system("pause");
    return 0;
}

效果图：

总结：

反转 ---reverse
排序 ---sort （成员函数）

3.7.8 排序案例

案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高

排序规则：按照年龄进行升序，如果年龄相同按照身高进行排序

示例：

#include <iostream>
using namespace std;
#include<string>
#include<list>

//list 容器 排序案例 对于自定义数据类型 做排序
//按照年龄进行升序，如果年龄相同按照身高进行降序

class Person
{
public:
    Person(string name, int age, int height)
    {
        this->m_Name = name;
        this->m_Age = age;
        this->m_Height = height;
    }
    string m_Name;//姓名
    int m_Age;//年龄
    int m_Height;//身高

};

//指定排序规则
bool compartPerson(Person &p1, Person &p2)
{
    //按照年龄 升序
    if (p1.m_Age==p2.m_Age)
    {
        //年龄相同  按照身高降序
        return p1.m_Height > p2.m_Height;
    }
    else
    { 
    return p1.m_Age < p2.m_Age;
    }
}
void test01()
{
    list<Person>L;//创建容器

    //准备数据
    Person p1("刘备",35 , 175);
    Person p2("曹操", 45, 180);
    Person p3("孙权", 40, 170);
    Person p4("赵云", 25, 180);
    Person p5("张飞", 35, 190);
    Person p6("关羽", 35, 160);
    Person p7("司马懿",20 ,200 );


    //插入数据
    L.push_back(p1);
    L.push_back(p2);
    L.push_back(p3);
    L.push_back(p4);
    L.push_back(p5);
    L.push_back(p6);
    L.push_back(p7);

    for (list<Person>::iterator it = L.begin();it!=L.end();it++)
    {
        cout << "姓名： " << (*it).m_Name << " 年龄 ： " << it->m_Age << " 身高： " << it->m_Height << endl;
    }

    //排序
    cout << "-------------------------------------" << endl;
    cout << "排序后" << endl;
    L.sort(compartPerson);

    for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
    {
        cout << "姓名： " << (*it).m_Name << " 年龄 ： " << it->m_Age << " 身高： " << it->m_Height << endl;
    }

}



int main()
{
    
    test01();
    
    system("pause");
    return 0;
}

效果图：

总结：

对于自定义数据类型，必须指定排序规则，否则编译器不知道如何进行排序
高级排序只是在排序规则上进行一次逻辑规则制定，并不复杂

liu嘿嘿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c++提高第三章STL容器之 list容器

3.7 list 容器3.7.1 list 基本概念功能：将数据进行链式存储链表(list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的链表的组成：链表由一系列结点组成结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域STL中的链表是一个双向循环链表由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器list 的优点采用动..
复制链接

扫一扫