STL容器之list

【1】list简介

实质上，list容器就是一个双向链表，可以高效地进行插入、删除操作。

【2】list链表常用方法

（1）构造、赋值、清空、删除、插入、判空等

应用示例代码如下：

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1;

    // 构造函数（构建一个list，有10个元素，每个元素值都是10）
    list<int> myList2(10, 10);
    print(myList2);

    // 拷贝构造函数
    list<int> myList3(myList2);
    print(myList3);

    // 由区间内的值初始化list
    int nArrayA[5] = {10, 20, 30, 40, 50};
    list<int> myList4(nArrayA, nArrayA + 5);
    print(myList4);

    // 赋值assign(input_iterator start, input_iterator end);
    myList1.assign(nArrayA, nArrayA + 4);
    print(myList1);

    // 赋值assign(size_type num, const Type & val);
    myList1.assign(10, 100);
    print(myList1);

    // 返回对最后一个元素的引用
    cout << myList4.back() << endl;

    // 返回对第一个元素的引用
    cout << myList4.front() << endl;

    // 清空链表clear
    myList4.clear();
    cout << myList4.empty() << endl;

    // 删除元素erase(iterator pos)
    list<int>::iterator iter = myList1.begin();
    for (; iter != myList1.end(); )
    {
        myList1.erase(iter++);
    }
    cout << myList1.empty() << endl;

    // 删除元素erase(iterator start, iterator end)
    myList3.erase(myList3.begin(), myList3.end());
    cout << myList3.empty() << endl;

    // 插入元素insert(iterator pos, const TYPE& val)
    myList1.insert(myList1.begin(), 110);
    print(myList1);

    // 插入元素insert(iterator pos, size_type num, const TYPE &val)
    myList1.insert(myList1.begin(), 10, 23);
    print(myList1);

    // 插入元素insert(iterator pos, input_iterator start, input_iterator end)
    int nArrayB[4] = {7, 8, 9, 10};
    myList1.insert(myList1.begin(), nArrayB, nArrayB + 4);
    print(myList1);

    system("pause");
}

// run out:
/*
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 10 10
10 20 30 40 50
10 20 30 40
100 100 100 100 100 100 100 100 100 100
50
10
1
1
1
110
23 23 23 23 23 23 23 23 23 23 110
7 8 9 10 23 23 23 23 23 23 23 23 23 23 110
请按任意键继续. . .
*/

（2）merge方法

请看如下最常见的崩溃代码：

代码1：链表1无序，链表2无序。

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1, myList2;
    // 赋值
    myList1.assign(2, 3);
    // 插入元素
    int nArrayA[5] = {7, 8, 9, 10, 11};
    myList1.insert(myList1.begin(), nArrayA, nArrayA + 5);
    // 追加元素
    for (int i = 10; i < 15; ++i)
    {
        myList1.push_back(i + 2);
    }
    cout << "打印链表1的数据：" << endl;
    print(myList1);

    
    myList2.push_back(23);
    myList2.push_back(20);
    myList2.push_back(47);
    myList2.push_back(36);
    myList2.push_back(87);
    cout << "打印链表2的数据：" << endl;

    print(myList2);

    myList1.merge(myList2);
    cout << "合并后，打印链表1的数据：" << endl;
    print(myList1);
    cout << "合并后，打印链表2的数据：" << endl;
    print(myList2);

    system("pause");
}

运行结果如下图：

代码2：链表1无序，链表2升序。

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1, myList2;
    // 赋值
    myList1.assign(2, 3);
    // 插入元素
    int nArrayA[5] = {7, 8, 9, 10, 11};
    myList1.insert(myList1.begin(), nArrayA, nArrayA + 5);
    // 追加元素
    for (int i = 10; i < 15; ++i)
    {
        myList1.push_back(i + 2);
    }
    cout << "打印链表1的数据：" << endl;
    print(myList1);

    
    myList2.push_back(20);
    myList2.push_back(23);
    myList2.push_back(36);
    myList2.push_back(37);
    myList2.push_back(87);
    cout << "打印链表2的数据：" << endl;

    print(myList2);

    myList1.merge(myList2);
    cout << "合并后，打印链表1的数据：" << endl;
    print(myList1);
    cout << "合并后，打印链表2的数据：" << endl;
    print(myList2);

    system("pause");
}

运行结果如下图：

代码3：链表1升序，链表2降序。

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1, myList2;
    // 赋值
    myList1.assign(2, 3);
    // 插入元素
    int nArrayA[5] = {7, 8, 9, 10, 11};
    myList1.insert(myList1.end(), nArrayA, nArrayA + 5);
    // 追加元素
    for (int i = 10; i < 15; ++i)
    {
        myList1.push_back(i + 2);
    }
    cout << "打印链表1的数据：" << endl;
    print(myList1);

    myList2.push_back(87);
    myList2.push_back(47);
    myList2.push_back(36);
    myList2.push_back(23);
    myList2.push_back(20);
    cout << "打印链表2的数据：" << endl;

    print(myList2);

    myList1.merge(myList2);
    cout << "合并后，打印链表1的数据：" << endl;
    print(myList1);
    cout << "合并后，打印链表2的数据：" << endl;
    print(myList2);

    system("pause");
}

运行结果如下图：

代码4：链表1降序，链表2降序。

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1, myList2;
    // 追加元素
    for (int i = 15; i > 10; --i)
    {
        myList1.push_back(i + 2);
    }
    cout << "打印链表1的数据：" << endl;
    print(myList1);

    myList2.push_back(50);
    myList2.push_back(49);
    myList2.push_back(48);
    myList2.push_back(47);
    myList2.push_back(46);
    cout << "打印链表2的数据：" << endl;

    print(myList2);

    myList1.merge(myList2);
    cout << "合并后，打印链表1的数据：" << endl;
    print(myList1);
    cout << "合并后，打印链表2的数据：" << endl;
    print(myList2);

    system("pause");
}

运行结果如下图：

代码5：链表1升序，链表2升序。

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1, myList2;
    // 赋值
    myList1.assign(2, 3);
    // 插入元素
    int nArrayA[5] = {7, 8, 9, 10, 11};
    myList1.insert(myList1.end(), nArrayA, nArrayA + 5);
    // 追加元素
    for (int i = 10; i < 15; ++i)
    {
        myList1.push_back(i + 2);
    }
    cout << "打印链表1的数据：" << endl;
    print(myList1);

    myList2.push_back(20);
    myList2.push_back(23);
    myList2.push_back(36);
    myList2.push_back(37);
    myList2.push_back(87);
    cout << "打印链表2的数据：" << endl;

    print(myList2);

    myList1.merge(myList2);
    cout << "合并后，打印链表1的数据：" << endl;
    print(myList1);
    cout << "合并后，打印链表2的数据：" << endl;
    print(myList2);

    system("pause");
}

运行结果如下图：

经过查资料及源码，发现问题是：

list链表合并merge方法注意事项：

1、合并的两个链表必须均默认升序的。即合并之前，两个链表就应该是由小到大顺序排列的。

2、合并完成后，被合并链表（myList2）数据元素被清空。

3、默认是按升序合并。比如上例4，若想按降序进行合并，需要指定降序。

修改后，如下代码：

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1, myList2;
    // 追加元素
    for (int i = 15; i > 10; --i)
    {
        myList1.push_back(i + 2);
    }
    cout << "打印链表1的数据：" << endl;
    print(myList1);

    myList2.push_back(50);
    myList2.push_back(49);
    myList2.push_back(48);
    myList2.push_back(47);
    myList2.push_back(46);
    cout << "打印链表2的数据：" << endl;

    print(myList2);

    myList1.merge(myList2, greater<int>());
    cout << "合并后，打印链表1的数据：" << endl;
    print(myList1);
    cout << "合并后，打印链表2的数据：" << endl;
    print(myList2);

    system("pause");
}

按降序进行合并。前提必须两个链表均为降序有序排列。

（3）remove方法。删除链表中所有值为val的元素。

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

// 打印链表数据信息
void print (const list<int> & tempList)
{
    // cbegin 返回指向第一个元素的迭代器
    // cend 返回指向最后一个元素之后位置的迭代器
    list<int>::const_iterator cIter = tempList.cbegin();
    for (; cIter != tempList.cend(); ++cIter)
    {
        cout << (*cIter) << " ";
    }
    cout << endl;
}

void main()
{
    // 构造函数（默认构造函数）
    list<int> myList1;
    myList1.assign(3, 12);
    myList1.insert(myList1.end(), 3, 34);
    for (int i = 15; i > 10; --i)
    {
        myList1.push_back(12);
    }
    for (int i = 10; i < 15; ++i)
    {
        myList1.push_front(i + 5);
    }
    cout << "打印链表的数据：" << endl;
    print(myList1);
    
    cout << "删除12后，打印链表数据：";
    myList1.remove(12);
    print(myList1);

    cout << "删除34后，打印链表数据：";
    myList1.remove(34);
    print(myList1);

    system("pause");
}

// run out:
/*
打印链表的数据：
19 18 17 16 15 12 12 12 34 34 34 12 12 12 12 12
删除12后，打印链表数据：19 18 17 16 15 34 34 34
删除34后，打印链表数据：19 18 17 16 15
请按任意键继续. . .
*/

（4）remove_if方法。用一元函数判断是否删除元素，若函数返回true，则删除该元素。

应用示例代码如下：

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

// 打印链表数据信息
 void print (const list<int> & tempList)
 {
     list<int>::const_iterator cIter = tempList.cbegin();
     for (; cIter != tempList.cend(); ++cIter)
     {
         cout << (*cIter) << " ";
     }
     cout << endl;
}

bool IsDel (int i) 
{ 
    return ((i % 2) == 1); 
}

void main () 
{
  int myInts[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  list<int> myList(myInts, myInts + 10);

  cout << "打印链表数据元素：" << endl;
  print(myList);
  myList.remove_if(IsDel);
  cout << "删除（val % 2 == 1）后打印链表数据元素：" << endl;
  print(myList);

  system("pause");
}

// run out:
/*
打印链表数据元素：
1 2 3 4 5 6 7 8 9 10
删除（val % 2 == 1）后打印链表数据元素：
2 4 6 8 10
请按任意键继续. . .
*/

（5）unique方法。移除重复元素。

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

// 打印链表数据信息
 void print (const list<int> & tempList)
 {
     list<int>::const_iterator cIter = tempList.cbegin();
     for (; cIter != tempList.cend(); ++cIter)
     {
         cout << (*cIter) << " ";
     }
     cout << endl;
}

void main()
{
    list<int> myList;
    myList.assign(5, 100);
    for (int i = 0; i < 5; ++i)
    {
        myList.push_front(i + 2);
    }
    for (int i = 0; i < 5; ++i)
    {
        myList.push_back(10 + i);
    }
    myList.insert(myList.end(), 5, 45);

    print(myList);
    myList.unique(); // 移除重复元素
    print(myList);

    system("pause");
}

// run out:
/*
6 5 4 3 2 100 100 100 100 100 10 11 12 13 14 45 45 45 45 45
6 5 4 3 2 100 10 11 12 13 14 45
请按任意键继续. . .
*/

（6）splice 粘接方法的三种方式

应用示例代码如下：

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

// 打印链表数据信息
 void print (const list<int> & tempList)
 {
     list<int>::const_iterator cIter = tempList.cbegin();
     for (; cIter != tempList.cend(); ++cIter)
     {
         cout << (*cIter) << " ";
     }
     cout << endl;
}

 void main()
 {
     list<int> myList1, myList2, myList3, myList4;
     myList1.assign(5, 10);
     myList2.push_front(22);
     cout << "打印myList2的数据：" << endl;
     print(myList2);
     cout << "打印myList1的数据：" << endl;
     print(myList1);
     // 粘接方法1：splice(iterator pos, list& lst)
     // 将myList1链表元素粘接到myList2链表的第一个位置(pos及其后元素均后移)
     myList2.splice(myList2.begin(), myList1);
     cout << "粘接后，打印myList2的数据：" << endl;
     print(myList2);
     cout << "粘接后，打印myList1的数据：" << endl;
     print(myList1);

     // 粘接方法2：splice(iterator pos, list& lst, iterator del)
     // 将myList1链表元素从第二个开始粘接到myList3链表的第一个位置
     myList1.assign(2, 11);
     myList3.assign(2, 22);
     cout << endl << "打印myList3的数据：" << endl;
     print(myList3);
     cout << "打印myList1的数据：" << endl;
     print(myList1);
     myList3.splice(myList3.begin(), myList1, ++myList1.begin());
     cout << "粘接后，打印myList3的数据：" << endl;
     print(myList3);
     cout << "粘接后，打印myList1的数据：" << endl;
     print(myList1);

     // 粘接方法3：splice(iterator pos, list& lst, iterator start, iterator end)
     // 将myList1链表元素从第二个开始粘接到myList4链表的第二个位置
     myList1.push_back(12);
     myList1.push_back(13);
     myList1.push_back(14);
     myList1.push_back(15);
     myList4.assign(4, 44);
     cout << endl << "打印myList4的数据：" << endl;
     print(myList4);
     cout << "打印myList1的数据：" << endl;
     print(myList1);
     myList4.splice(++myList4.begin(), myList1, ++myList1.begin(), myList1.end());
     cout << "粘接后，打印myList4的数据：" << endl;
     print(myList4);
     cout << "粘接后，打印myList1的数据：" << endl;
     print(myList1);

     system("pause");
 }
 
 // run out:
 /*
 打印myList2的数据：
22
打印myList1的数据：
10 10 10 10 10
粘接后，打印myList2的数据：
10 10 10 10 10 22
粘接后，打印myList1的数据：


打印myList3的数据：
22 22
打印myList1的数据：
11 11
粘接后，打印myList3的数据：
11 22 22
粘接后，打印myList1的数据：
11

打印myList4的数据：
44 44 44 44
打印myList1的数据：
11 12 13 14 15
粘接后，打印myList4的数据：
44 12 13 14 15 44 44 44
粘接后，打印myList1的数据：
11
请按任意键继续. . .
 */

（7）swap方法。交换两个链表中的元素。

应用示例代码如下：

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

// 打印链表数据信息
 void print (const list<int> & tempList)
 {
     list<int>::const_iterator cIter = tempList.cbegin();
     for (; cIter != tempList.cend(); ++cIter)
     {
         cout << (*cIter) << " ";
     }
     cout << endl;
}

void main()
{
    list<int> myList1, myList2;
    for (int i = 0; i < 10; ++i)
    {
        myList1.push_back(rand() % 100);
    }
    for (int j = 0; j < 10; ++j)
    {
        myList2.push_back(rand() % 200);
    }
    cout << "打印myList1的数据：" << endl;
    print(myList1);
    cout << "打印myList2的数据：" << endl;
    print(myList2);
    myList1.swap(myList2);
    cout << "交换后，打印myList1的数据：" << endl;
    print(myList1);
    cout << "交换后，打印myList2的数据：" << endl;
    print(myList2);

    system("pause");
}
// run out:
/*
打印myList1的数据：
41 67 34 0 69 24 78 58 62 64
打印myList2的数据：
105 145 81 27 161 91 195 142 27 36
交换后，打印myList1的数据：
105 145 81 27 161 91 195 142 27 36
交换后，打印myList2的数据：
41 67 34 0 69 24 78 58 62 64
请按任意键继续. . .
*/

（8）待续。。。。

【3】list与vector区别总结

数组与链表的优缺点；   

数组:

优点：访问效率高，内存为连续的区域。

缺点：添加、删除操作效率低。大小固定，不适合动态存储(不方便动态添加)。

链表：

优点：一般内存不连续。添加、删除效率高。大小可变。  

缺点：只能通过指针顺序访问，查询效率低。

Good  Good  Study, Day  Day  Up.

顺序  选择  循环  总结