C++ list容器学习总结

----------------------------list

        链表是由一系列的结点组成，结点包含两个域，一个数据域，一个指针域

        链表内存是非连续的

        添加和删除元素 其时间复杂度都为常数项，不需要移动元素，比数组添加删除效率更高

        链表不是只有在需要的时候才分配内存

        链表需要额外的空间保存节点关系 前驱、后继关系

----------特性总结

        采用动态存储分配，不会造成内存浪费和溢出

        链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

        链表灵活，但是空间和时间额外耗费较大

----------list常用API

list构造函数

         list<T> lstT;   list采用模板类实现，对象的默认构造形式

         list(beg,end);  构造函数将[beg,end)区间中的元素拷贝给本身

         list(n,elem);   构造函数将n给elem拷贝给本身

         list(const list& lst);  拷贝构造函数

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值匹配的元素

list大小操作

         size(); 返回容器中元素的个数

         empty();    判断容器是否为空

         reserve(num);   重新制定容器的长度为num，若容器变长的，则以默认值填充新位置

list赋值操作

         assign(beg,end);    将[beg,end)区间中的数据拷贝赋值给本身

         ssign(n,elem);  将n个elem拷贝赋值给本身

         list& operator= (const list& lst);  重载=操作符

         swap(lst);  将lst与本身的元素互换

list数据存取

         front();    返回第一个元素

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

list反转排列排序

         reverse();  反转链表，比如lst包含1，3，5元素，运行此方法后lst就包含5，3，1元素

         sort(); list排序

---

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

void test01 () {
    list<int> lst1;
    list<int> lst2(10,10);  //有参构造
    list<int> lst3(lst2);   //拷贝
    list<int> lst4(lst2.begin(),lst2.end());

    for (list<int>::iterator it = lst4.begin();it != lst4.end();it ++) {
        cout << *it << " ";
    }
    cout << endl;
}

void test02 () {
    list<int> lst;
    lst.push_back(100);
    lst.push_front(200);
    lst.push_front(200);
    lst.push_front(200);
    lst.push_back(300);
    lst.push_back(200);
    lst.push_back(200);
    lst.push_back(400);

    lst.insert(lst.begin(),500);
    lst.insert(lst.end(),600);

    list<int>::iterator it = lst.begin();
    it ++;it ++;
    lst.insert(it,700);

    // lst.pop_back();
    // lst.pop_front();

    // lst.erase(lst.begin(),lst.begin());

    lst.remove(200);   //删除匹配的所有值
    for (list<int>::iterator it = lst.begin();it != lst.end();it ++) {
        cout << *it << " ";
    }
    cout << endl;
}

//交换
void test03 () {
    list<int> lst1;
    lst1.assign(10,10);
    
    list<int> lst2;
    lst2 = lst1;
    
    lst2.swap(lst1);
}

//旋转
void test04 () {
    list<int> lst;
    for (int i = 0;i < 10;i ++) {
        lst.push_back(i);
    }
    for (list<int>::iterator it = lst.begin();it != lst.end();it ++) {
        cout << *it << " ";
    }
    cout << endl;

    lst.reverse();
    for (list<int>::iterator it = lst.begin();it != lst.end();it ++) {
        cout << *it << " ";
    }
    cout << endl;    
}

bool cmp (int t1,int t2) {
    return t1 > t2;
}

//排序
void test05 () {
    list<int> lst;
    lst.push_back(2);
    lst.push_back(211);
    lst.push_back(6);
    lst.push_back(3);
    lst.push_back(55);
    lst.push_back(1);

    //默认从小到大
    lst.sort();
    for (list<int>::iterator it = lst.begin();it != lst.end();it ++) {
        cout << *it << " ";
    }
    cout << endl;

    lst.sort(cmp);
    for (list<int>::iterator it = lst.begin();it != lst.end();it ++) {
        cout << *it << " ";
    }
    cout << endl;
}