C++基础（7.Stack_Quene_List）

List介绍及其用法：

std::list 是 C++ 标准库中的一个双向链表容器，适合于频繁插入和删除操作。以下是 std::list 的常用接口和重载的详细介绍。

1. 基本构造函数

• 默认构造函数：

  std::list<int> lst;
  

  创建一个空的 list。

• 指定大小的构造函数：

  std::list<int> lst(size_t n);
  

  创建一个包含 n 个元素的 list，元素值初始化为默认值（对于基本类型为 0）。

• 指定大小和初始值的构造函数：

  std::list<int> lst(size_t n, const int& value);
  

  创建一个包含 n 个元素的 list，所有元素初始化为 value。

• 拷贝构造函数：

  std::list<int> lst(const std::list<int>& other);
  

  通过拷贝另一个 list 的内容来初始化。

• 移动构造函数：

  std::list<int> lst(std::list<int>&& other) noexcept;
  

  通过移动另一个 list 的内容来初始化，避免不必要的拷贝。

2. 赋值运算符

• 拷贝赋值运算符：

  std::list<int>& operator=(const std::list<int>& other);
  

  将一个 list 的内容复制到另一个 list。

• 移动赋值运算符：

  std::list<int>& operator=(std::list<int>&& other) noexcept;
  

  将一个 list 的内容移动到另一个 list。

3. 大小和容量

• size()：

  size_t size() const;
  

  返回当前 list 中元素的数量。

• empty()：

  bool empty() const;
  

  检查 list 是否为空。

4. 访问元素

• front()：

  T& front();
  const T& front() const;
  

  返回第一个元素的引用。

• back()：

  T& back();
  const T& back() const;
  

  返回最后一个元素的引用。

5. 修改元素

• push_back()：

  void push_back(const T& value);
  void push_back(T&& value);
  

  在 list 的末尾添加一个元素。

• push_front()：

  void push_front(const T& value);
  void push_front(T&& value);
  

  在 list 的前面添加一个元素。

• pop_back()：

  void pop_back();
  

  删除 list 的最后一个元素。

• pop_front()：

  void pop_front();
  

  删除 list 的第一个元素。

• insert()：

  iterator insert(iterator pos, const T& value);
  iterator insert(iterator pos, T&& value);
  iterator insert(iterator pos, size_t n, const T& value);
  template <class InputIt>
  iterator insert(iterator pos, InputIt first, InputIt last);
  

  在指定位置插入一个或多个元素。

• erase()：

  iterator erase(iterator pos);
  iterator erase(iterator first, iterator last);
  

  删除指定位置或范围的元素。

• clear()：

  void clear();
  

  删除所有元素。

6. 其他功能

• swap()：

  void swap(std::list<T>& other) noexcept;
  

  交换两个 list 的内容。

• assign()：

  void assign(size_t n, const T& value);
  template <class InputIt>
  void assign(InputIt first, InputIt last);
  

  重新赋值 list 的内容。

7. 迭代器

list 提供了多种迭代器支持，包括：

• begin() 和 end()：

  iterator begin();
  iterator end();
  const_iterator begin() const;
  const_iterator end() const;
  

  返回指向第一个元素和最后一个元素之后位置的迭代器。

• rbegin() 和 rend()：

  reverse_iterator rbegin();
  reverse_iterator rend();
  const_reverse_iterator rbegin() const;
  const_reverse_iterator rend() const;
  

  返回指向最后一个元素和第一个元素之前位置的反向迭代器。

注意：

list 支持许多标准算法，比如 sort、remove_if 等，但需要注意的是，某些算法可能需要额外的考虑，因为 list 的随机访问性能较差。适合于频繁的插入和删除操作。

---

Stack介绍及其用法： 

stack 是 C++ 标准库中的一个容器适配器，提供了后进先出的数据结构。它是基于其他容器（如 deque 或vector）实现的。

1. 基本构造函数

• 默认构造函数：

  std::stack<T> s;
  

  创建一个空的 stack，底层使用默认的容器（通常是 std::deque）。

• 指定底层容器的构造函数：

  std::stack<T, Container> s;
  

  创建一个空的 stack，使用指定的容器类型 Container。

2. 赋值运算符

• 拷贝赋值运算符：

  std::stack<T>& operator=(const std::stack<T>& other);
  

  将一个 stack 的内容复制到另一个 stack。

3. 大小和容量

• size()：

  size_t size() const;
  

  返回 stack 中元素的数量。

• empty()：

  bool empty() const;
  

  检查 stack 是否为空。

4. 修改元素

• push()：

  void push(const T& value);
  void push(T&& value);
  

  向 stack 的顶部添加一个元素。

• pop()：

  void pop();
  

  移除 stack 顶部的元素。

5. 访问元素

• top()：

  T& top();
  const T& top() const;
  

  返回 stack 顶部元素的引用，但不移除该元素。

6. 其他功能

• swap()：

  void swap(std::stack<T>& other) noexcept;
  

  交换两个 stack 的内容。

7. 迭代器

stack 本身不提供迭代器，因为它是一个适配器。不过，如果需要迭代，可以通过底层容器访问。

8. 示例代码

以下是一个简单的stack 使用示例：

#include <iostream>
#include <stack>

int main() {
    std::stack<int> s;

    // 添加元素
    s.push(1);
    s.push(2);
    s.push(3);

    // 输出栈顶元素
    std::cout << "Top element: " << s.top() << std::endl; // 输出 3

    // 移除栈顶元素
    s.pop();
    std::cout << "Top element after pop: " << s.top() << std::endl; // 输出 2

    // 输出栈的大小
    std::cout << "Stack size: " << s.size() << std::endl; // 输出 2

    // 检查栈是否为空
    std::cout << "Is stack empty? " << (s.empty() ? "Yes" : "No") << std::endl; // 输出 No

    return 0;
}

---

Quene介绍及其用法： 

std::queue 是 C++ 标准库中的一个容器适配器，提供了先进先出（FIFO）的数据结构。它通常基于其他容器（如 std::deque 或 std::list）实现。以下是 std::queue 的常用接口和重载的详细介绍。

1. 基本构造函数

• 默认构造函数：

  std::queue<T> q;
  

  创建一个空的 queue，底层使用默认的容器（通常是 std::deque）。

• 指定底层容器的构造函数：

  std::queue<T, Container> q;
  

  创建一个空的 queue，使用指定的容器类型 Container。

2. 赋值运算符

• 拷贝赋值运算符：

  std::queue<T>& operator=(const std::queue<T>& other);
  

  将一个 queue 的内容复制到另一个 queue。

3. 大小和容量

• size()：

  size_t size() const;
  

  返回 queue 中元素的数量。

• empty()：

  bool empty() const;
  

  检查 queue 是否为空。

4. 修改元素

• push()：

  void push(const T& value);
  void push(T&& value);
  

  向 queue 的尾部添加一个元素。

• pop()：

  void pop();
  

  移除 queue 前面的元素。

5. 访问元素

• front()：

  T& front();
  const T& front() const;
  

  返回 queue 前面元素的引用，但不移除该元素。

• back()：

  T& back();
  const T& back() const;
  

  queue 尾部元素的引用，但不移除该元素。

6. 其他功能

• swap()：

  void swap(std::queue<T>& other) noexcept;
  

  交换两个 queue 的内容。

7. 迭代器

queue 不提供迭代器，因为它一样是一个适配器

8. 示例代码

以下是一个简单的queue 使用示例：

#include <iostream>
#include <queue>

int main() {
    std::queue<int> q;

    // 添加元素
    q.push(1);
    q.push(2);
    q.push(3);

    // 输出队首元素
    std::cout << "Front element: " << q.front() << std::endl; // 输出 1

    // 移除队首元素
    q.pop();
    std::cout << "Front element after pop: " << q.front() << std::endl; // 输出 2

    // 输出队列的大小
    std::cout << "Queue size: " << q.size() << std::endl; // 输出 2

    // 检查队列是否为空
    std::cout << "Is queue empty? " << (q.empty() ? "Yes" : "No") << std::endl; // 输出 No

    return 0;
}