STL常用容器(6)--list容器

1 list容器基本概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。

List和vector是两个最常被使用的容器。

List容器是一个双向循环链表。

• 采用动态存储分配，不会造成内存浪费和溢出
• 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
• 链表灵活，但是空间和时间额外耗费较大
  
  
  
  

2 list容器的迭代器

list容器不能像vector一样以普通指针作为迭代器，因为其节点不能保证在同一块连续的内存空间上。List迭代器必须有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取操作。所谓”list正确的递增，递减、取值、成员取用”是指，递增时指向下一个节点，递减时指向上一个节点，取值时取的是节点的数据值，成员取用时取的是节点的成员。

由于list是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是Bidirectional Iterators.

list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效，甚至list元素的删除，也只有被删除的那个元素的迭代器失效，其他迭代器不受任何影响。

3 list容器的数据结构

list容器不仅是一个双向链表，而且还是一个循环的双向链表.

4 list常用API

4.1 list构造函数

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

4.2 list数据元素插入和删除操作

push_back(elem);		//在容器尾部加入一个元素
pop_back();				//删除容器中最后一个元素
push_front(elem);		//在容器开头插入一个元素
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值匹配的元素。

4.3 list大小操作

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

4.4 list赋值操作

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

4.5 list数据的存取

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

4.6 list反转排序

reverse();		//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
sort(); 		//list排序,升序

5 案例

5.1 内置数据类型

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

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

int main()
{
    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.insert(L.begin(), 100);
    printList(L);

    // remove移除
    L.remove(100);
    printList(L);

    L.pop_front();
    printList(L);

    L.pop_back();
    printList(L);

    cout << "L.size() = " << L.size() << endl;

    cout << "L.back() = " << L.back() << endl;
        
    cout << "L.front() = " << L.front() << endl;

    L.reverse();
    printList(L);

    L.sort();
    printList(L);

    return 0;
}

5.2 自定义数据类型

对于自定义数据类型需要指定出排序规则，否则无法进行排序;

1. 方法一：在自定义数据类型中重载 " < " [bool operator<()]
2. 方法二：写一个函数，指定排序规则

对于自定义数据类型需要指定 " == "号，才能使用remove;

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

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

    // 重载== 使list容器的remove使用
    bool operator==(const Person &p) 
    {   
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age && this->m_Hight == p.m_Hight)
        {   
            return true;
        }   
        return false;
    }   

#if 0
    // 方法一
    bool operator<(const Person& p)     // 重载<
    {
        if (this->m_Age == p.m_Age)     // 如果年龄相同，按照身高升序排列
        {
            return this->m_Hight < p.m_Hight;
        }
        return this->m_Age < p.m_Age;   // 年龄不同，按照年龄升序排列
    }
#endif

    string m_Name;      // 姓名
    int    m_Age;       // 年龄
    int    m_Hight;     // 身高
};

#if 1
// 方法二
bool myCompare(const Person& p1, const Person& p2)  // 写一个函数，指定排序规则
{   
    if (p1.m_Age == p2.m_Age)
    {   
        return p1.m_Hight < p2.m_Hight; // 写一个函数，指定排序规则
    }
    return p1.m_Age < p2.m_Age;         // 写一个函数，指定排序规则
}
#endif


int main()
{
    list<Person> L;

    Person p1("张三", 18, 170);
    Person p2("李四", 20, 170);
    Person p3("王五", 20, 172);
    Person p4("小明", 17, 173);
    Person p5("小红", 17, 173);

    L.push_back(p1);
    L.push_back(p2);
    L.push_back(p3);
    L.push_back(p4);
    L.push_back(p5);


    for (auto it = L.begin(); it != L.end(); ++it)
    {
        cout << "姓名:" << it->m_Name << " 年龄:" << it->m_Age << " 身高:" << it->m_Hight << endl;
    }
    cout << "============================" << endl;
    cout << "排序之后的数据:" << endl;

#if 0
    L.sort();           // 重载<号的调用方法
#endif

#if 1
    L.sort(myCompare);  // 写一个函数，指定排序规则的调用方法
#endif

    for (auto it = L.begin(); it != L.end(); ++it)
    {
        cout << "姓名:" << it->m_Name << " 年龄:" << it->m_Age << " 身高:" << it->m_Hight << endl;
    }

    L.remove(p1);

    cout << "===========================" << endl;
    cout << "删除张三之后的数据:" << endl;
    for (auto it = L.begin(); it != L.end(); ++it)
    {
        cout << "姓名:" << it->m_Name << " 年龄:" << it->m_Age << " 身高:" << it->m_Hight << endl;
    }


    return 0;
}