【C++】STL——list的介绍和使用、list增删查改函数的介绍和使用、push_back、pop_back_c++ stl中在list开头或末尾插入元素

1.list的使用

list构造函数的介绍和使用

 

2.list的增删查改函数

（1）push_front 在list首元素前插入值为val的元素

  push_front()函数用于将一个新的元素插入到链表的开头位置。 通过调用push_front()函数并将待插入的元素作为参数传递给该函数，即可实现在链表开头插入新元素的操作。

  和链表的插入一样，push_front()函数的时间复杂度为O(1)，因为在双向链表中插入元素到开头位置的操作只涉及到指针的重新链接，而不需要移动其他元素。

  以下是关于push_front()函数的定义和使用示例：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {2, 3, 4};
    
    // 使用 push_front() 在链表开头插入元素
    myList.push_front(1);
    
    // 输出链表中的元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

//1 2 3 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 

（2）pop_front 删除list中第一个元素

  pop_front()函数用于删除链表的第一个元素。

  pop_front()函数的时间复杂度为O(1)，因为在双向链表中删除开头元素的操作只涉及到指针的重新链接，而不需要移动其他元素。

  以下是关于pop_front()函数的定义和使用示例：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4};

    // 使用 pop_front() 删除链表的第一个元素
    myList.pop_front();

    // 输出链表中的元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

//2 3 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 

（3）push_back 在list尾部插入值为val的元素

  push_back()函数用于将一个元素插入到链表的末尾位置。 通过调用push_back()函数并将待插入的元素作为参数传递给该函数，即可实现在链表末尾插入新元素的操作。

  以下是关于push_back()函数的定义和使用示例：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};

    // 使用 push_back() 在链表末尾插入元素
    myList.push_back(4);

    // 输出链表中的元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

//1 2 3 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 

（4）pop_back 删除list中最后一个元素

  pop_back()函数用于删除std::list容器中的最后一个元素。

  以下是关于pop_back()函数的使用和定义示例：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4};

    // 使用pop_back()删除链表的最后一个元素
    myList.pop_back();

    // 输出链表中的元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

//1 2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 

（5）insert 在list position 位置中插入值为val的元素

  insert()函数用于在指定位置插入一个或多个元素。 通过提供插入位置的迭代器，并使用单个元素或迭代器范围作为参数，即可实现在指定位置插入新元素的操作。

  insert()函数的时间复杂度取决于插入的元素个数，如果只插入一个元素，则时间复杂度为O(1)，如果插入多个元素，则时间复杂度为插入位置后元素个数的线性复杂度。

  以下是关于insert()函数的定义和使用示例：

  我们使用范围for循环遍历链表中的元素，并将它们输出。在循环体内，通过element变量获取当前元素的值，并将其输出。

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4};

    // 在第二个位置插入元素
    auto it = std::next(myList.begin()); // 获取迭代器指向第二个位置
    myList.insert(it, 5);

    // 在第三个位置插入多个元素
    std::list<int> newElements = {6, 7};
    it = std::next(myList.begin(), 2); // 获取迭代器指向第三个位置
    myList.insert(it, newElements.begin(), newElements.end());

    // 输出链表中的元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

//1 5 6 7 2 3 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

 

（6）erase 删除list position位置的元素

  erase()函数用于从链表中删除一个或多个元素。

  以下是关于erase()函数的定义和使用示例：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4};

    // 删除第三个位置上的元素
    auto it = std::next(myList.begin(), 2); // 获取迭代器指向第三个位置
    myList.erase(it);

    // 删除第二到第四个位置上的元素
    auto first = std::next(myList.begin(), 1); // 获取迭代器指向第二个位置
    auto last = std::next(myList.begin(), 4); // 获取迭代器指向第五个位置
    myList.erase(first, last);

    // 输出链表中的元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

//1 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

 

（7）swap 交换两个list中的元素

  swap()函数用于交换两个对象的值。

  以下是关于swap()函数的定义和使用示例：

#include <iostream>
#include <vector>

int main() {
    int a = 5;
    int b = 10;

    // 使用 swap() 函数交换两个整数值
    std::swap(a, b);

    std::cout << "a: " << a << std::endl;
    std::cout << "b: " << b << std::endl;

    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = {4, 5, 6};

    // 使用 swap() 函数交换两个向量的值
    std::swap(vec1, vec2);

    std::cout << "vec1: ";
    for (const auto& element : vec1) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    std::cout << "vec2: ";
    for (const auto& element : vec2) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

//a: 10
//b: 5
//vec1: 4 5 6
//vec2: 1 2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

 

（8）clear 清空list中的有效元素

  clear()函数用于清空链表，即删除链表中的所有元素。

  clear()函数的时间复杂度为O(N)，其中N是链表中的元素个数。在清空链表时，clear()函数会对每个元素调用析构函数来释放内存。

  以下是关于clear()函数的定义和使用示例：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4};

    // 使用 clear() 函数清空链表
    myList.clear();

    // 输出链表中的元素个数
    std::cout << "Size of myList after clear: " << myList.size() << std::endl;

    return 0;
}

//Size of myList after clear: 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16