Linux C++ 030-STL之list容器

Linux C++ 030-STL之list容器

本节关键字：Linux、C++、list
相关库函数：push_front、pop_front、back、end

list基本概念

概念：链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现
功能：将数据进行链式存储
链表的组成：链表由一系列结点组成
结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

注：STL中的链表是一个双向循环链表。
关键词：

push_front();
push_back();
pop_front();
pop_back();
front();
back();
begin();
end();
insert();

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

链表的缺点：
（1）链表灵活，但是空间(指针域) 和时间（遍历）额外消耗较大
（2）链表有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的

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

list构造函数

功能描述：创建list容器
函数原型：

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

示例：

#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);
    
    printList(L1);
    
    list<int> L2(L1.begin(), L1.end());
    printList(L2);
    
    list<int> L3(L2);
    printList(L3);
    
    list<int> L4(10, 1000);
    printList(L4);
}

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

list赋值和交换

功能描述：给list容器进行赋值，以及交换list容器
函数原型：

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

示例：

#include <list>

void peintList(const list<int> &L)
{
    for(list<int>::const_iterator it = L.brgin();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);
    
    printList(L1);
    
    list<int> L2;
    L2 = L1;
    printList(L2);
    
    list<int> L3;
    L3.assign(L2.begin(), L2.end());
    printList(L3);
    
    list<int> L4;
    L4.assign(10, 100);
    printList(L4);
}

void test02()
{
    list<int> L1;
    
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    
    list<int> L2;
    L2.assign(10, 100);
    cout << "交换前：" << endl;
    printList(L1);
    printList(L2);
    
    L1.swap(L2);
    cout << "交换后：" << endl;
    printLis(L1);
    printLis(L2);
}

list大小操作

功能描述：对list容器的大小进行操作
函数原型：

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

示例：

#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);
    
    if( L1.empty() )
    {
        cout << "L1为空" << endl;
    }
    else
    {
        cout << "L1不为空" << endl;
        printList(L1);
        cout << "L1的元素个数为：" << L1.size() <<endl;
    }
    
    L1.resize(10);
    printList(L1);
    
    L1.resize(10, 1000);
    printList(L1);
    
    L1.resize(1);
    printList(L1);
}

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 <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容器
    list<int> L;
    
    //尾插
    L.push_back(10);
    L.push_back(20);
    L.push_back(30);
    
    //头插
    L.push_front(100);
    L.push_front(200);
    L.push_front(300);
    
    printList(L);
    
    //尾删
    L.pop_back();
    printList(L);
    
    //头删
    L.pop_front();
    printList(L);
    
    //元素指针 - 指定位置插入
    list<int>::iterator it = L.begin();
    L.insert(++it, 1000);
    printList(L);
    
    //擦除
    it = L.begin();
    L.erase(++it);
    printList(L);
    
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    printList(L);
    
    //移除一类相同数据
    L.remove(10000);
    printList(L);
    
    //清除容器内所有数据
    L.clear();
    printList(L);
}

list数据存取

功能描述：对list容器中的数据进行存取
函数原型：

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

不可以用 [] 和 at() 访问元素的原因是list本质是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的
示例：

#include <list>

void printList(const list<int> &L)
{
    for(list<int>::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);
    
    printList(L1);
    
    cout << "第一个元素为：" << L1.front() << endl;
    cout <<"最后一个元素为：" << L1.back() << endl;
    
    //验证迭代器是不支持随机访问的
    list<int>::iterator it = L1.begin();
    it++;//正确，支持双向
    it--;
    //it = it + 1;//错误，不支持随机访问
    
}

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

list反转和排序

功能描述：将容器中的元素反转，以及将容器中的数据进行排序
函数原型：

reverse();	//反转链表
sort();		//链表排序 默认排序规则  从小到大，升序

示例：

#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;
}

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

void test01()
{
    list<int> L;
    L.push_back(1);
    L.push_back(3);
    L.push_back(4);
    L.push_back(2);
    L.push_back(5);
    printList(L);
    
    //默认排序规则  从小到大，升序
    //这里演示降序，后边还会讲解
    L.sort(myCompare);
    printList(L);
    
    L.reverse();
    printList(L);
}

排序案例

案例描述：将Person自定义数据类型进行排序，Person属性有姓名、年龄、身高
排序规则：按照年龄进行升序，如果年龄相同按照身高降序

#include <iostram>
#include <string>
#include <list>

using namespace std;

class Person
{
public:
    Person(string name, int age, int height)
    {
        this->m_Name = name;
        this->m_Age = age;
        this->m_Height = height;
    }
    pravite:
    string m_Name;
    int m_Age;
    int m_Height
};

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

//指定排序规则 - 年龄升序，身高降序
bool comparePerson(Person &p1, Person &p2)
{
    if(p1.m_Age == p2.m_Age)
    {
        //年龄相同，按照身高降序
        return p1.m_Height > p2.m_Height;
    }
    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, 190);
    Person p5("张飞", 35, 160);
    Person p6("关羽", 35, 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);
    
    printList(L);
    
    cout << "---------------------------" << endl;
    cout << "排序后：" << endl;
    L.sort(comparePerson);
    printList(L);
}

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