一、链表的基本概念

        链表（Linked List）是一种物理存储单元上非连续的、非顺序的线性数据结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。相比于线性数组，链表的好处在于不需要事先分配固定大小的存储空间，并且在插入和删除数据时不需要移动其他元素。

        最适合比喻链表的就是火车了，如下图所示。

二、链表的类型

        C++中常见的链表类型包括单向链表、双向链表和循环链表。

        1. 单向链表（Singly Linked List）

                单向链表是最简单的链表结构，每个节点只包含一个指向下一个节点的指针。单向链表只能从头节点开始顺序访问到尾节点。

                示例：在链表头部插入节点，遍历链表并打印节点的数据，代码如下。

#include <iostream>
// 定义单向链表的节点结构体
struct Node {int data;           // 数据域Node* next;        // 指针域，指向下一个节点// 构造函数，用于初始化节点Node(int data) : data(data), next(nullptr) {}
};
// 单向链表类
class SinglyLinkedList {
private:Node* head; // 头节点指针public:SinglyLinkedList() : head(nullptr) {}// 在链表头部插入节点void insertAtBeginning(int data) {Node* newNode = new Node(data);newNode->next = head;head = newNode;}// 遍历链表并打印节点的数据void printList() {Node* temp = head;while (temp != nullptr) {std::cout << temp->data << " ";temp = temp->next;}std::cout << std::endl;}// 销毁链表~SinglyLinkedList() {Node* temp;while (head != nullptr) {temp = head;head = head->next;delete temp;}}
};
int main() {SinglyLinkedList list;list.insertAtBeginning(5);list.insertAtBeginning(3);list.insertAtBeginning(1);list.printList();return 0;
}

                结果如下所示：

        2. 双向链表（Doubly Linked List）

                双向链表包含两个指针，一个指向前一个节点，另一个指向下一个节点。这使得双向链表可以从任何一个节点向前或向后遍历。

                 示例：在链表头部插入节点，遍历链表并打印节点的数据，代码如下。

#include <iostream>
// 定义双向链表的节点结构体
struct Node {int data;           // 数据域Node* prev;         // 指针域，指向前一个节点Node* next;         // 指针域，指向下一个节点// 构造函数，用于初始化节点Node(int data) : data(data), prev(nullptr), next(nullptr) {}
};
// 双向链表类
class DoublyLinkedList {
private:Node* head; // 头节点指针
public:DoublyLinkedList() : head(nullptr) {}// 在链表头部插入节点void insertAtBeginning(int data) {Node* newNode = new Node(data);if (head != nullptr) {head->prev = newNode;}newNode->next = head;head = newNode;}// 遍历链表并打印节点的数据void printList() {Node* temp = head;while (temp != nullptr) {std::cout << temp->data << " ";temp = temp->next;}std::cout << std::endl;}// 销毁链表~DoublyLinkedList() {Node* temp;while (head != nullptr) {temp = head;head = head->next;if (temp->next != nullptr) {temp->next->prev = temp->prev;}delete temp;}}
};
int main() {DoublyLinkedList list;list.insertAtBeginning(5);list.insertAtBeginning(3);list.insertAtBeginning(1);list.printList(); return 0;
}

                在上述2个示例中，我们定义了节点结构体，并为单向链表和双向链表创建了类。这些类包含了插入节点到链表头部、遍历链表并打印节点数据以及销毁链表的方法。对于双向链表，我们还需要处理`prev`指针以确保链表结构的正确性。

                请注意，以上代码只是一个简单的示例，并没有处理错误情况和异常。在实际应用中，你可能需要添加额外的错误检查和边界情况处理，例如当插入节点失败时返回错误码或抛出异常。此外，对于大型数据集，你可能还需要考虑性能优化和内存管理。

        3. 循环链表（Circular Linked List）

                循环链表与单向链表和双向链表的主要区别在于，循环链表的尾节点指向头节点，形成一个环状结构。这使得循环链表可以从任何节点开始遍历整个链表。循环链表是链表结构的一个变种，它的特点是链表的最后一个节点指向链表的第一个节点，形成一个环状结构。在实际开发中，循环链表常用于实现某些特殊的数据结构，如循环队列、循环双端队列等。

                我们举一个实例：假设我们正在开发一个音乐播放器应用，需要实现一个音乐播放列表，这个播放列表支持添加、删除、循环播放音乐的功能。循环链表非常适合用来实现这样的播放列表。

                首先，我们定义一个循环链表的节点类，每个节点包含一个音乐信息和一个指向下一个节点的指针。代码如下。

#include <iostream>
#include <string>
class MusicNode {
public:std::string title;    // 音乐标题MusicNode* next;       // 指向下一个节点的指针MusicNode(const std::string& title) : title(title), next(nullptr) {}
};

                接着，我们定义一个循环链表类，包含插入、删除、遍历等基本操作。代码如下。

class CircularMusicPlaylist {
private:MusicNode* head;       // 头节点int size;               // 链表大小public:CircularMusicPlaylist() : head(nullptr), size(0) {}~CircularMusicPlaylist() {clear();}// 插入音乐到播放列表void addMusic(const std::string& title) {MusicNode* newNode = new MusicNode(title);if (isEmpty()) {head = newNode;newNode->next = head; // 构成循环} else {MusicNode* current = head;while (current->next != head) {current = current->next;}current->next = newNode;newNode->next = head; // 新节点指向头节点，形成闭环}size++;}// 从播放列表中删除音乐void removeMusic(const std::string& title) {if (isEmpty()) {return;}MusicNode* prev = nullptr;MusicNode* current = head;do {if (current->title == title) {if (prev == nullptr) { // 删除的是头节点while (current->next != head) {current = current->next;}head = head->next;delete current;head->next = head; // 更新头节点的指针} else {prev->next = current->next;if (current == head) {head = prev->next;}delete current;}size--;return;}prev = current;current = current->next;} while (current != head); // 遍历整个链表std::cout << "Music not found in the playlist." << std::endl;}// 遍历播放列表void play() {if (isEmpty()) {std::cout << "Playlist is empty." << std::endl;return;}MusicNode* current = head;do {std::cout << "Playing: " << current->title << std::endl;current = current->next;} while (current != head); // 循环播放}// 判断播放列表是否为空bool isEmpty() const {return head == nullptr;}// 清除播放列表void clear() {MusicNode* current = head;while (current != nullptr) {MusicNode* toDelete = current;current = current->next;delete toDelete;}head = nullptr;size = 0;}// 获取播放列表大小int getSize() const {return size;}
};

                现在，我们可以使用这个循环链表播放列表了。代码如下。

int main() {CircularMusicPlaylist playlist;// 添加音乐到播放列表playlist.addMusic("Song 1");playlist.addMusic("Song 2");playlist.addMusic("Song 3");// 打印播放列表大小std::cout << "Playlist size: " << playlist.getSize() << std::endl;// 播放整个播放列表playlist.play();// 删除一个歌曲playlist.removeMusic("Song 2");// 再次打印播放列表大小std::cout << "Playlist size after removal: " << playlist.getSize() << std::endl;// 再次播放整个播放列表playlist.play();// 清除播放列表playlist.clear();// 检查播放列表是否为空if (playlist.isEmpty()) {std::cout << "Playlist is now empty." << std::endl;}return 0;
}

                上述代码中，我们首先创建了一个`CircularMusicPlaylist`对象，然后向其中添加了几首歌曲。我们打印了播放列表的大小，并播放了整个播放列表。之后，我们删除了一个歌曲，并再次打印了播放列表的大小。最后，我们清除了播放列表，并检查它是否为空。

                通过实现一个音乐播放列表，我们展示了循环链表的基本操作，包括添加元素、删除元素、遍历元素以及检查链表是否为空。在实际应用中，循环链表还可以用于实现各种需要循环访问数据结构的场景，如循环队列、环形缓冲区等。