C++实现面向对象单链表：从基本概念到完整代码

创作时间:

作者:

@小白创作中心

C++实现面向对象单链表：从基本概念到完整代码

引用

CSDN

https://m.blog.csdn.net/2302_81410974/article/details/145525612

链表是一种常见的数据结构，特别是在动态数据管理、频繁插入和删除元素的场景中。本文将详细介绍如何用C++语言实现一个面向对象的单链表，深入探讨链表的核心操作，并展示完整的代码示例。

一、单链表的基本概念

单链表是一种由节点组成的线性数据结构，其中每个节点包含数据部分和指向下一个节点的指针。与数组不同，链表的节点在内存中不要求连续存储，而是通过指针连接。因此，链表的插入和删除操作较为灵活，不需要大量的数据移动。

在C++中，我们通过类的封装特性来实现面向对象的链表，这不仅能有效管理链表的内存，还能通过封装实现更易用、更安全的操作。

二、单链表类的设计

我们将通过一个简单的C++类来实现单链表，该类包含基本的链表操作，如插入、删除、打印链表等。

1. 节点的定义

首先，我们定义了一个Node结构体来表示链表中的每个节点。每个节点包含一个数据部分data和一个指向下一个节点的指针next。

struct Node {
    int data;      // 数据域
    Node* next;    // 指针域，指向下一个节点
};

2. 链表的类定义

接下来，我们定义List类，它包含一个指向链表头部的指针phead，以及若干成员函数来实现链表的常见操作。

class List {
private:
    Node* phead; // 链表头指针
public:
    // 构造函数
    List() : phead(nullptr) {}
    // 析构函数
    ~List() {
        while (phead != nullptr) {
            PopFront();
        }
    }
    // 创建节点
    Node* CreateNode(int x) {
        Node* node = new Node;
        node->data = x;
        node->next = nullptr;
        return node;
    }
    // 打印链表
    void PrintList() {
        Node* cur = phead;
        while (cur) {
            cout << cur->data << "-->";
            cur = cur->next;
        }
        cout << "NULL" << endl;
    }
    // 头插法
    void PushFront(int x) {
        Node* newNode = CreateNode(x);
        newNode->next = phead;
        phead = newNode;
    }
    // 尾插法
    void PushBack(int x) {
        Node* newNode = CreateNode(x);
        if (phead == nullptr)
            phead = newNode;
        else {
            Node* tail = phead;
            while (tail->next != nullptr) {
                tail = tail->next;
            }
            tail->next = newNode;
        }
    }
    // 头删
    void PopFront() {
        if (phead == nullptr)
            cout << "链表为空，无法进行删除操作！" << endl;
        else {
            Node* del = phead;
            phead = del->next;
            delete del;
            del = nullptr;
        }
    }
    // 尾删
    void PopBack() {
        if (phead == nullptr)
            cout << "链表为空，无法进行删除操作！" << endl;
        else {
            if (phead->next == nullptr) {
                delete phead;
                phead = nullptr;
            } else {
                Node* tail = phead;
                while (tail->next->next != nullptr) {
                    tail = tail->next;
                }
                delete tail->next;
                tail->next = nullptr;
            }
        }
    }
};

三、单链表的操作实现

PushFront: 在链表的头部插入新节点。
PushBack: 在链表的尾部插入新节点。
PopFront: 删除链表的头节点。
PopBack: 删除链表的尾节点。
PrintList: 打印链表中的所有节点。

四、测试与演示

下面的main函数展示了如何使用上述链表类实现基本操作：

int main() {
    List ls1;  // 创建一个链表对象
    // 进行一些操作
    ls1.PushBack(1);
    ls1.PushBack(2);
    ls1.PushBack(3);
    ls1.PushBack(4);
    ls1.PushBack(5);
    // 打印链表
    ls1.PrintList();
    // 头删除和尾删除
    ls1.PopFront();
    ls1.PopBack();
    // 头插操作
    ls1.PushFront(9);
    // 打印链表
    ls1.PrintList();
    return 0;
}

五、链表操作的复杂度

PushFront和PopFront：这两个操作的时间复杂度为 O(1)，因为它们仅仅操作链表的头节点。
PushBack和PopBack：这两个操作的时间复杂度为 O(n)，需要遍历整个链表，直到找到尾节点。
PrintList：打印链表的时间复杂度为 O(n)，需要遍历所有节点。

六、完整代码

#include<iostream>
using namespace std;
//节点类型声明
struct Node
{
    int date;
    Node* next;
};
class List
{
private:
    //成员变量
    Node* phead;
public:
    //成员函数
    List() : phead(nullptr) {}//构造函数
    ~List()//析构函数
    {
        while(phead!=NULL)
        {
            PopFront();
        }
    }
    Node* CreateNode(int x)//创建节点
    {
        Node* node=new Node;
        node->date=x;
        node->next=NULL;
        return node;
    }
    void PrintList()//打印链表
    {
        Node *cur=phead;
        while(cur)
        {
            cout<<cur->date<<"-->";
            cur=cur->next;
        }
        cout<<"NULL"<<endl;
    }
    void PushFront(int x)//头插
    {
        Node*newnode=CreateNode(x);
        newnode->next=phead;
        phead=newnode;
    }
    void PushBack(int x)//尾插
    {
        Node*newnode=CreateNode(x);
        if(phead==NULL)
            phead=newnode;
        else
        {
            Node* tail = phead;
            while (tail->next != NULL)
            {
                tail = tail->next;
            }
            tail->next = newnode;
        }
    }
    void PopFront() //头删
    {
        if (phead==NULL)
            cout<<"链表为空，无法进行删除操作！"<<endl;
        else
        {
            Node* del=phead;
            phead=del->next;
            delete del;
            del=NULL;
        }
    }
    void PopBack()  //尾删
    {
        if (phead== NULL)
            cout<<"链表为空，无法进行删除操作！"<<endl;
       else
        {
           if(phead->next==NULL)
           {
               delete phead;
               phead=NULL;
           }
           else
           {
               Node* tail = phead;
               while (tail->next->next != NULL)
               {
                   tail = tail->next;
               }
               delete tail->next;
               tail->next=NULL;
           }
        }
    }
};
int main()
{
    List ls1;
    ls1.PushBack(1);
    ls1.PushBack(2);
    ls1.PushBack(3);
    ls1.PushBack(4);
    ls1.PushBack(5);
    ls1.PrintList();
    ls1.PopFront();
    ls1.PopBack();
    ls1.PushFront(9);
    ls1.PrintList();
    return 0;
}