C++：链表

已于 2023-04-19 21:30:35 修改
阅读量246 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法基础（C++） 文章标签： c++ 开发语言
于 2023-03-14 11:08:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28414091/article/details/129519968
文章展示了两个C++实现的链表节点类，一个数据和指针是私有的，通过成员函数进行操作，另一个则是数据和指针公开。同时，文章提供了插入和删除节点的示例，以及一个完整的链表类，包括节点插入、删除、数据访问和链表管理等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据和指针隐藏的节点类
#include<bits/stdc++.h>
using namespace std;

template <class T>
class cNode  //单链表节点类 
{  
    T m_data;  //数据域  
    cNode<T> *m_next; //指向下一个结点
public:
     cNode(const T& item, cNode<T> *ptr=NULL); //ptr: 后继节点 
     ~cNode() { }
     cNode<T> *next();          //返回后继结点
     void insertAfter(cNode<T> *p);//本结点后插入节点p
     cNode<T> *delAfter();         //删除本结点之后的结点并返回
     T getData() { return m_data; }
};

//template<class T>
//cNode<T>::cNode(const T& item, cNode<T> *ptr=NULL)
//{   m_data = item;
// m_next = ptr;
//}
template<class T>
cNode<T>::cNode(const T& item, cNode<T> *ptr)
{   
    m_data = item;
     m_next = ptr;
}

template<class T>
cNode<T> *cNode<T>::next()
{   
    return m_next;
}

template<class T>
void  cNode<T>::insertAfter(cNode<T> *p)
{   
    p->m_next = m_next;    
     m_next = p;
}

template<class T>
cNode<T> *cNode<T>::delAfter()
{  
    if(!m_next) return NULL; //无后继节点
     cNode<T> *ptr = m_next;
     m_next = m_next->m_next;
     return ptr;
}


/*测试方法：增加了函数getData()（也可以不增加，但m_data要改为公有成员）；
            构造3个节点的链，输出每个节点的数据;
   删除中间节点，然后输出每个节点的数据。
*/ 
int main()
{ 
    cNode<int> nd1(100), nd2(200), nd3(300), *p;
     nd1.insertAfter(&nd2);
     nd1.insertAfter(&nd3);
     p = &nd1;
     while(p)
     { 
         cout<<p->getData()<<" ";
          p = p->next();
     }
     cout<<endl;
 
     nd1.delAfter();
     p = &nd1;
     while(p)
     { 
         cout<<p->getData()<<" ";
          p = p->next();
     }
     cout<<endl;
     return 0;
}
数据和指针公开的节点类
#include<bits/stdc++.h>
using namespace std;

template <class T>
class cNode  //单链表节点类.简单起见，成员均为public 
{
public:  
     T   data;  //数据域  
     cNode<T> *next;  //指向下一个结点
 
     cNode(const T& item)
    { 
        data = item; next = NULL; 
    }
     ~cNode() { }
};

int main()
{ 
    cNode<int> nd1(100), nd2(200), nd3(300), *p;
     nd1.next = &nd3; nd3.next = &nd2;
     p = &nd1;
     while(p)
     { 
         cout<<p->data<<" ";
          p = p->next;
     }
     cout<<endl;
 
     nd1.next = nd1.next->next;
     p = &nd1;
     while(p)
     { 
         cout<<p->data<<" ";
          p = p->next;
    }
     cout<<endl;
     return 0;
}

可以添加附加头结点，储存无效数据，使得头节点永不为NULL，便于一些判断

完整的链表类
#include <iostream>
using namespace std;

//节点类
template<class T>
class Node
{
public:
    T data;//数据域 
    Node<T>* next;//指针域
    //构造函数1
    Node()
    {
        next = NULL;
    } 
    //构造函数2
    Node(const T& item)
    {
        data = item;
        next = NULL;    
    } 
    //#### ~Node();//析构函数 
    //获取下一节点指针
    Node<T> *NextNode() const;
    //删除结点
    Node *DeleteAfter()
    {
        //保存当前节点的后继结点 
        Node<T> *ptr = next;
        //若没有后继结点返回空指针
        if (ptr == NULL)
            return NULL;
        //当前结点指向其原来后继的后继，即ptr的后继
        next = ptr->next;
        //返回被删除结点的指针
        return ptr; 
    }
    
    //得到该结点的值
    Node<T> *getdata()const
    {
        return data;
    }
};

//指针类 
template<class T>
class LinkedList
{
private:
    Node<T> *front, *rear, *head, *ptr;//指向表头、表尾的指针 
    Node<T> *cur,  *pre;//用于指向当前和前一个结点的指针 
    
    int size;//当前节点个数 
    int position;//当前位置 
    
    //申请及释放单链表结点空间的函数
    Node<T> *GetNode(const T& item, Node<T> *ptr = NULL);
    void FreeNode(Node<T> * p);
    
public:
    LinkedList();//构造函数 
    ~LinkedList();//析构函数 
    //重载的赋值运算符
    LinkedList<T>& operator = (const LinkedList<T> & orgList);
    //获取单链表的结点个数
    int Size() const;
    //判断单链表是否为空
    bool empty()const;
    //重新定位当前单链表结点
    int NextNode();
    int SetPosition(int pos);
    int GetPosition() const;
    
    //插入结点
    void InsertAfter(const T& item);//当前位置之后插入节点 
    void InsertAt(const T& item); //就在当前位置插入节点 
    
    //删除链表结点的函数
    void DeleteAt();
    void DeleteAfter();
    
    //修改和访问数据的函数 
    T GetData()const;
    void SetData (const T& item);
    
    //清空链表的函数
    void Clear(); 
};

//申请及释放单链表结点空间的函数
template<class T>
Node<T> *LinkedList<T>::*GetNode(const T& item, Node<T> *ptr = NULL)
{
    Node<T> *newNode = new Node<T>(item, ptr);
    //若动态内存申请失败则给出相应的提示并返回空指针
    if(!newNode)
    {
        cout << "申请失败" <<endl;
        return NULL;
    } 
    //返回新生成的结点指针
    return newNode; 
} 
template<class T>
void LinkedList<T>::FreeNode(Node<T> * p)
{
    //若ptr为空，给出相应提示并返回
    //####if(!ptr)
    if(!p)
    {
        cout << "FreeNode error!" << endl;
        return; 
    } 
    //释放结点占用的内存空间
    //####delete ptr；
    delete p;
    return; 
}

//构造函数 (建立一个空链表)
template<class T>
LinkedList<T>::LinkedList()
{
    //####head = pre = new Node<T>(0,NULL);//附加头结点
    head = pre = new Node<T>(0);
    front = rear = NULL;
    cur = NULL;
    
    size = 0;
    position = -1;
}
//析构函数
template<class T>
LinkedList<T>::~LinkedList()
{
    //清空单链表，释放所有的结点空间
    Clear(); 
}

//单链表类中重载赋值运算符的函数
template<class T>
LinkedList<T>& LinkedList<T>::operator = (const LinkedList<T>& orgList)
{
    Node<T> *p = orgList.front;
    //清空本链表
    Clear();
    //将单链表 orgList中的元素复制到本单链表
    while(p)
    {
        InsertAfter(p->data);
        p = p->NextNode();
    } 
    //设置当前结点
    SetPosition(orgList.position);
    return *this;
} 

//获取表的大小
template<class T>
int LinkedList<T>::Size() const
{
    return size;
} 

//判断表是否为空
template<class T>
bool LinkedList<T>::empty() const
{
    if (size == 0)
        return true;
    else
        return false;
}

//将后继结点设置为当前结点的函数
template<class T>
int LinkedList<T>::NextNode()
{
    //若当前结点存在，则将其后继结点设置为当前节点
    if (position >= 0 && position < size)
    {
        position++;
        pre = cur;
        //####cur = cur->NextNode();
        cur = cur->next;
    } 
    else//否则将当前位置设为表尾 
    {
        position++;

    }
    return position;//返回新位置 
}

//重置当前结点的位置
template<class T>
int LinkedList<T>::SetPosition(int pos)
{
    if (!size)//若链表为空 
        return -1;
    if (pos < 0 ||pos > size - 1)
    {
        cout << "越界" << endl;
        return -1; 
    } 
    pre = NULL;
    cur = front;
    position = 0;
    for (int k = 0; k < pos; k++)
    {
        position++;
        pre = cur;
        cur = cur->next;
    }
    return position;//返回当前结点的位置 
}

//取出当前结点位置
template<class T>
int LinkedList<T>::GetPosition() const
{
    return position;
}

//在当前结点后插入结点
template<class T>
void LinkedList<T>::InsertAfter(const T& item)
{
    //####Node<T> *p = new Node<T>(item, NULL);
    Node<T> *p = new Node<T>(item);
    if (!cur)//空链表 
    {
        head->next = p;
        rear = p;
        //####此处加入设置front指针
        front = p;
    }
    else
    {
        p->next = cur->next;//不考虑位置：头、中间、尾 
        cur->next = p;
        if (!p->next)//当前位置是链尾 
            rear = p;
    }
    size++;
    cur = p;//cur指向新结点 
} 

//在当前结点处插入新的结点
template<class T>
void LinkedList<T>::InsertAt(const T& item)
{
    Node<T> *p = new Node<T>(item, NULL);
    p->next = cur;
    pre->next = p;
    cur = p;
    size++;
    if (!rear)//尾结点为空，说明是空链 
    {
        rear = p;
        //####此处加入设置front指针
        front = p;
    }
} 

//删除当前结点
template<class T>
void LinkedList<T>::DeleteAt()
{
    Node<T> *oldNode;
    if(!cur)//若链表为空或已经到达表尾 
    {
        cout << "DeleleAt:current position is invalid!" << endl;
        return;
    }
    
    if (!pre)//说明要删除的是表头结点 
    {
        oldNode = front;
        front = cur->next;
    }
    else//说明要删除的是表中结点 
    {
        oldNode = pre->DeleteAfter();
    } 
    if (oldNode == rear)//删除表尾结点，则修改表尾指针 
    {
        rear = pre; 
    }
    cur = oldNode->next;//后继结点作为新的结点
    FreeNode(oldNode);//释放当前结点
    size--;//链表大小减一 
}

//删除当前结点后继
template<class T>
void LinkedList<T>::DeleteAfter()
{
    Node<T> *oldNode;
    if (!cur || cur == rear)//若无当前结点或者已经到达链表尾 
    {
        cout << "DeleteAfter:current position in invalid!" << endl; 
        return;
    }
    oldNode = cur->DeleteAfter();//保存被删除的结点指针并删除该节点 
    if (oldNode == rear)//删除的是表尾结点 
    {
        rear = cur;    
    } 
    FreeNode(oldNode);
    
} 

//获取当前结点数据
template<class T>
//####T LinkedLlist<T>::GetData() const
T LinkedList<T>::GetData() const
{
    if (!cur)//若链表为空或已经到达表尾
    {
        cout << "Data:current node not exist!" << endl;
        return NULL;
    } 
    return cur->data;
} 

//修改当前结点数据
template<class T>
//####void LinkedList<T>::Setdata(const T& item)
void LinkedList<T>::SetData(const T& item)
{
    if (!cur)//若链表位空或已经到达表尾
    {
        cout << "Data:current node does not exist!" << endl;
        return;
    } 
    cur->data = item;//修改当前结点的数据 
} 

//清空链表
template<class T>
void LinkedList<T>::Clear()
{
    Node<T> *cur = front, *nextNode;
    while (cur)
    {
        nextNode = cur->next;//保存后继结点指针 
        FreeNode(cur);//释放当前结点
        cur = nextNode;//原后继结点成为当前结点 
    }
    //修改链表数据
    front = rear = pre = cur = NULL;
    size = 0; 
    position = -1; 
} 
 


int main()
{
    LinkedList<int> L;

    for (int i = 0; i<=10; i++)
    {
        L.InsertAfter(i);
    }

    L.SetPosition(0);
    cout << "LinkedList:  " << endl;
    while(L.NextNode() !=  L.Size())
    {
        cout <<L.GetData() << " ";
    } 
    cout << endl;
}
C++:链表去重算法​(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-16 576
C++:链表去重算法​(附完整源码)
C++：链表元素去重算法（带完整源码）
James_CODER的博客
08-29 536
定义一个指针 p 指向链表的头节点，遍历整个链表，每次取出一个节点，判断节点的值是否已经在 map 中出现过。如果节点的值没有在 map 中出现过，则说明此时链表中不存在相同的节点，将该节点存入 map 容器中并将 p 指针向后移动一位；下面我将向大家介绍一种行之有效的链表去重算法，并提供完整源码以及相应的描述。创建一个 map 容器，将链表的头节点存入 map 容器中，因为此时链表中肯定不含有重复的元素。希望能对大家有所帮助！当 p 指针遍历完整个链表后，链表去重操作完成，返回链表头节点即可。
数据结构之链表——C++具体实现
weixin_45338443的博客
05-18 363
由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。下面为其定义，初始化，添加元素，插入元素，删除元素，销毁，打印顺序表的具体代码实现~链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
C++课--单链表的基本操作
weixin_50518617的博客
06-09 1492
链表是一种重要的数据结构，能够动态地进行存储分配的一种结构链表，它与数组比较是不用事先确定存储空间， 链表的实现方式有两种（其实是我只会这两种） 第一种：是通过结构体指针实现。（课本上讲的就是这种方法） 第二种：是通过数组模拟实现。即链式向前星（不需要掌握） 这两种只是实现方式不同，本质是相同的； 下面讲解单链表如何实现： 首先链表的每个节点分为数据域和指针域； 头指针Head指向第一个元素 第一个元素存储第一个数据和指针域指向第二个元素的地址 （第二个元素不必要紧挨着第一个元素） 第二个元素存储第二个数据
单链表（C++）
weixin_63198483的博客
11-14 1480
数据结构与算法---单链表上的各项操作（C++）
C++链表部分
bili_orange的博客
04-05 253
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。重新定义两个指针，一个指针从头节点出发，一个从相遇的节点出发，各走一步，下一次相遇的地方就是环的入口节点。双链表有两个指针域，一个指向下一个节点，一个指向上一个节点。链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。
数据结构与算法——链表的c++实现
m0_68963624的博客
04-08 1386
后面补充双向链表等！
C++(数据结构)：链表
08-03
C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 ...
解锁C/C++：链表数据结构的奇幻之旅
邓邓子的博客
02-04 1365
在 C 和 C++ 中实现链表，不仅能够深入理解链表这种数据结构的原理和机制，还能锻炼我们对指针、内存管理等重要编程概念的掌握和运用能力。无论是对于学习数据结构和算法的初学者，还是对于有一定编程经验的开发者来说，通过 C 和 C++ 实现链表都是一项非常有价值的实践。它能够帮助我们提升编程技能，培养解决问题的能力，为进一步学习和应用更复杂的数据结构和算法打下坚实的基础。
C++实例：链表实现图书管理系统
03-16
学习尝试，代码不完美，请多包涵
C++高级匹配中的NEXT[ ]函数
03-16
高级匹配中的NEXT[ ]函数 部分代码 while(pb1->next!=null) { temp=pb1;//临时指针等于pb1 zutemp=zu;//数组中的位子 cout<<"kankan"<<endl; if(temp->data!=pb2->data&&pb2==headb->next) { if(B[zu]==null) { B[zu]=1; cout<<"b["<<zu<<"]="<<1<<endl; } } else while(pb2->next!=null&&temp!=null)//&&temp->data==pb2->data) { if(temp->data==pb2->data) { cout<<"内环"<<endl; if(B[zu]==null) { cout<<"B["<<zu<<"]="<<j<<endl; B[zu]=j; } j++; zu++; pb2=pb2->next; temp=temp->next; } else if(B[zu]==null) { B[zu]=j; cout<<"b["<<zu<<"]="<<j<<endl; break; } }//内while zu=zutemp+1; pb1=pb1->next; pb2=headb->next; j=1; }//外while
单链表的概念以及相关操作（C++）
smart_jackli的博客
10-28 954
本文介绍了单链表的概念，以及其相关基本操作，附代码。
【C++】链表
mjiansun的专栏
11-21 1762
链表相对于结构体就多了个next指针，next指针指向下一个对象就行。 目录 链表概念 链表特征 链表的构造 链表的遍历 查找链表中的对象 有头链表与无头链表 无头链表 有头链表 插入和删除 链表概念 把若干个对象用指针串联起来，形成一个链状的数据结构，称之为“链表”。 链表特征 链表头：指链表中的第一个对象。 链表尾：指链表中的最后一个对象。它的next必须设为...
LeetCode-116. 填充每个节点的下一个右侧节点指针
Wenrui Xie的博客
02-20 771
题目描述： 给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下： struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有next 指针都被设置为 NULL。 示例： 输入：root = [1,2,3,4,5,6,7] 输出...
数据结构笔记——链表
关于我的学习记录
12-05 2444
数据结构笔记——链表
利用C++超详细解释数据结构中的链表
Mr.林先生的博客
03-24 3201
链表是一种线性数据结构，它由一系列节点组成，每个节点包含两个部分：数据部分和指针部分。数据部分用来存储节点的数据，指针部分用来指向下一个节点。int val;// 数据部分// 指针部分，指向下一个节点ListNode(int x) : val(x), next(nullptr) {} // 构造函数其中，val表示节点的数据，next指向下一个节点的指针。构造函数用来初始化节点的数据和指针部分。
C++: 链表的综合运用
qq_50585766的博客
08-02 511
目录 （1）实验目的 （2）实验内容 （3）参考界面 （4）主要源代码 （1）实验目的： 利用所学的C语言知识实现对链表的基本操作。 （2）实验内容： 实现初始化或重置链表，销毁链表，链表中数据元素个数查询，所指位序的元素值，找出链表已存在元素的位序，请输入元素,求直接前驱，请输入元素,求直接后继，在第i个位置插入元素，删除第i个元素，输出所输入的链表元素，初始化并输入链表元素等功能。 （3）参考界面： （4）主要源代码： #include &...
C++循环链表
最新发布
Excalibur6的博客
04-15 279
循环链表是单链表和双链表的一种演化，原理是一样的，只是逻辑上需要改一下，像单链表，他的结构是头节点->尾节点->nll，循环链表只需要把尾节点的next由原来的指向null改为指向头节点，遍历链表的时候，到null会判定遍历结束，而循环链表是回到头部节点的时候遍历结束，这里要注意设置好遍历逻辑，不然会出现死循环。双链表的循环同理，这里就不去实现它了，想学习实现他参考我之前写的单链表和双链表实现的文章，里面有程序，拿出来改下逻辑就行了，这里就介绍一下。
LeetCode刷题（十九）-----链表-------medium部分（Java、C++）
chenbo的博客
12-30 361
138. 复制带随机指针的链表 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。 要求返回这个链表的深拷贝。 示例： 输入： {“KaTeX parse error: Expected '}', got 'EOF' at end of input: …:"1","next": {"id”:“2”,“next”:null,“random”: {“KaT...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值