【C++】“list”的介绍和常用接口的模拟实现

引言

在 C++ 标准模板库（STL）中，std::list 是一个双向链表实现，它允许在任意位置高效地插入和删除元素。与 std::vector 相比，std::list 的插入和删除操作不会导致数据移动，因此在处理大量数据时具有一定的优势。本文将介绍 list 的基本概念，并提供一个简单的模拟实现，展示其常用接口。

list 的基本特性

• 双向链表：每个节点都包含指向前后节点的指针，允许在链表的两端进行插入和删除操作。
• 动态大小：list 可以根据需要动态调整大小，而不需要事先定义大小。
• 随机访问性能较差：由于是链表结构，随机访问的性能较差，访问时间复杂度为 O(n)。

常用接口

在这篇文章中，我们将实现以下 list 接口：

1. 插入元素（在头部和尾部插入）
2. 删除元素
3. 访问元素
4. 获取当前大小

代码实现

以下是一个简单的 List 类的实现：

#include <iostream>
#include <stdexcept>

template <typename T>
class ListNode {
public:
    T data;              // 节点数据
    ListNode* next;      // 指向下一个节点的指针
    ListNode* prev;      // 指向前一个节点的指针

    ListNode(const T& value) : data(value), next(nullptr), prev(nullptr) {}
};

template <typename T>
class List {
private:
    ListNode<T>* head;   // 链表头
    ListNode<T>* tail;   // 链表尾
    size_t size;         // 当前元素个数

public:
    // 构造函数
    List() : head(nullptr), tail(nullptr), size(0) {}

    // 析构函数
    ~List() {
        clear(); // 释放所有节点内存
    }

    // 在头部插入元素
    void push_front(const T& value) {
        ListNode<T>* newNode = new ListNode<T>(value);
        if (size == 0) {
            head = tail = newNode; // 新节点成为头尾
        } else {
            newNode->next = head;   // 新节点指向当前头
            head->prev = newNode;   // 当前头的前指针指向新节点
            head = newNode;         // 更新头指针
        }
        ++size; // 增加大小
    }

    // 在尾部插入元素
    void push_back(const T& value) {
        ListNode<T>* newNode = new ListNode<T>(value);
        if (size == 0) {
            head = tail = newNode; // 新节点成为头尾
        } else {
            newNode->prev = tail;  // 新节点的前指针指向当前尾
            tail->next = newNode;   // 当前尾的后指针指向新节点
            tail = newNode;        // 更新尾指针
        }
        ++size; // 增加大小
    }

    // 删除头部元素
    void pop_front() {
        if (size == 0) {
            throw std::out_of_range("List is empty");
        }
        ListNode<T>* temp = head; // 保存当前头
        head = head->next;        // 更新头指针
        if (head) {
            head->prev = nullptr;  // 更新新的头的前指针
        } else {
            tail = nullptr;        // 如果链表为空，更新尾指针
        }
        delete temp; // 释放旧头的内存
        --size;      // 减少大小
    }

    // 删除尾部元素
    void pop_back() {
        if (size == 0) {
            throw std::out_of_range("List is empty");
        }
        ListNode<T>* temp = tail; // 保存当前尾
        tail = tail->prev;        // 更新尾指针
        if (tail) {
            tail->next = nullptr;  // 更新新的尾的后指针
        } else {
            head = nullptr;        // 如果链表为空，更新头指针
        }
        delete temp; // 释放旧尾的内存
        --size;      // 减少大小
    }

    // 访问元素
    T& front() {
        if (size == 0) {
            throw std::out_of_range("List is empty");
        }
        return head->data; // 返回头部数据
    }

    T& back() {
        if (size == 0) {
            throw std::out_of_range("List is empty");
        }
        return tail->data; // 返回尾部数据
    }

    // 获取当前大小
    size_t getSize() const {
        return size;
    }

    // 清空链表
    void clear() {
        while (size > 0) {
            pop_front(); // 删除头部元素
        }
    }
};

int main() {
    List<int> myList; // 创建一个整数类型的 List

    // 在头部插入元素
    myList.push_front(1);
    myList.push_front(2);
    myList.push_front(3);
    std::cout << "After push_front: " << myList.front() << " at front, size: " << myList.getSize() << std::endl;

    // 在尾部插入元素
    myList.push_back(4);
    myList.push_back(5);
    std::cout << "After push_back: " << myList.back() << " at back, size: " << myList.getSize() << std::endl;

    // 删除元素
    myList.pop_front();
    std::cout << "After pop_front: " << myList.front() << " at front, size: " << myList.getSize() << std::endl;

    myList.pop_back();
    std::cout << "After pop_back: " << myList.back() << " at back, size: " << myList.getSize() << std::endl;

    // 清空链表
    myList.clear();
    std::cout << "After clear, size: " << myList.getSize() << std::endl;

    return 0;
}

代码详解

1. 节点类 ListNode

ListNode 类用于表示链表的节点，包含节点的数据、指向下一个节点和前一个节点的指针。

2. List 类

• 构造函数和析构函数：初始化头、尾和大小。在析构函数中，调用 clear 方法释放所有节点的内存。

• 插入方法：

  • push_front：在头部插入新节点，更新头指针。
  • push_back：在尾部插入新节点，更新尾指针。

• 删除方法：

  • pop_front：删除头部节点，更新头指针。
  • pop_back：删除尾部节点，更新尾指针。

• 访问方法：

  • front：返回头部节点的数据。
  • back：返回尾部节点的数据。

• 获取大小：getSize 返回当前链表中的元素数量。

• 清空链表：clear 方法删除链表中的所有元素。

运行结果

运行上述代码将输出对插入、删除和清空操作的结果，展示 List 类的基本功能。

总结

通过以上实现，我们模拟了 C++ 中 std::list 的基本功能。这个简单的实现帮助我们理解链表的结构和操作。希望这篇文章能帮助你更好地理解 C++ 中的链表容器。