【数据结构（C++）】单链表

最新推荐文章于 2024-11-01 21:13:19 发布
最新推荐文章于 2024-11-01 21:13:19 发布
阅读量768 收藏 3
点赞数
分类专栏： VC++学习 文章标签： 数据结构 c++ null delete insert list
本文详细介绍了C++中单链表的数据结构，包括节点类、单链表类的定义和基本操作，如构造、判断空、获取长度、遍历、插入、删除和链接等。并通过学生结构体的实例演示了如何使用单链表来存储和操作数据。

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

      线性表包含 数据域和指针域 其中，data存储数据本身的值，next存储后继元素的地址 下面的图表示的是一个数据节点

单链表的结构示意图（包括空的单链表）：

 

 

 

  1. 单链表的节点类:
    复制代码 
    template<class T>
    class Node
    {
        public:
            T data;//数据
            Node<T> *next;//next指针
            Node()
            {
                this->next=NULL;//构造空的节点
            }
            Node(T data,Node<T> *next=NULL)//构造一个节点
            {
                this->data=data;
                this->next=next;
            }
    };
    复制代码
  2. 单链表类声明如下：
    复制代码 
    #include<iostream>
    #include "Node.h" //单链表节点类
    template<class T>
    class SinglyLinkedList //单链表类
    {
        public:
            Node<T> *head;//单链表的头指针。
            SinglyLinkedList();//构造空的单链表。
            SinglyLinkedList(T value[], int n);//构造由指定的数组提供的单链表
            ~SinglyLinkedList();//析构
            bool isEmpty();//判断是否为空。
            int length();//获取长度
            Node<T>* getNode(int i);//返回第i(i>=0)个节点指针
            T get(int i);//返回第i个元素
            bool set(int i,T x);//设置第i个元素为x
            template<class T> friend std::ostream&  operator<<(std::ostream& out,SinglyLinkedList<T> &list);
            Node<T>* insert(int i,T x);//插入第I个节点并返回第i个节点的指针
            bool remove(int i,T& old);//删除第i个元素，将删除的元素存放到old
            void clear();//清空单链表
            void concat(SinglyLinkedList<T> &list);//将List链接在当前单链表之后
    };
    复制代码
  3. 单链表部分如构造空的链表对象，析构，判断为空的实现，没有要讲的算法，实现如下：
    复制代码 
    template<class T>
    SinglyLinkedList<T>::SinglyLinkedList()//构造空的单链表
    {
        this->head=NULL;
    }
    template<class T>
    SinglyLinkedList<T>::~SinglyLinkedList()//析构
    {
        clear();
    }
    template<class T>
    bool SinglyLinkedList<T>::isEmpty()//判断链表是否为空
    {
        return this->head==NULL;
    }
    复制代码
  4. 单链表的遍历操作，遍历单链表是指从第一个节点开始访问，沿着节点的Next可依次访问单链表中的各个节点，并且各个节点只被访问一次。实现的单链表遍历的基本算法如下：
    复制代码 
    int j=0;
        Node<T> *p=head;
        while(p!=NULL&&j<i)
        {
            j++;
            p=p->next;
        }
    复制代码

    单链表的length(),get(),set(),clear()和输出等操作都基于以上算法。

    复制代码 
    template<class T>
    int SinglyLinkedList<T>::length()
    {
        int i=0;
        Node<T> *p=head;//创建一个用于遍的变量
        while(p!=NULL)
        {
            i++;
            std::cout<<p->data;
            p=p->next;
        }
        return i;
    }
    template<class T>
    Node<T>* SinglyLinkedList<T>::getNode(int i)
    {
        if(i<0)
            return NULL;
        int j=0;
        Node<T> *p=head;
        while(p!=NULL&&j<i)
        {
            j++;
            p=p->next;
        }
        return p;
    }
    template<class T>
    T SinglyLinkedList<T>::get(int i)
    {
        Node<T> *p=getNode(i);
        if(p!=NULL)
            return p->data;
        T d;
        return d;
        //throw "单链表为空或者参数指定的元素不存在";
    }
    template<class T>
    bool SinglyLinkedList<T>::set(int i,T x)
    {
        Node<T> *p=getNode(i);
        if(p!=NULL)
        {
            p->data=x;
            return true;
        }
        return false;
    }
    template<class T> 
    std::ostream&  operator<<(std::ostream& out,SinglyLinkedList<T> &list)
    {
        Node<T> *p=list.head;
        out<<"(";
        while(p!=NULL)
        {
            out<<p->data;
            p=p->next;
            if(p!=NULL)
                out<<",";
        }
        out<<")\n";
            return out;
    }
    template<class T>
    void SinglyLinkedList<T>::clear()
    {
        Node<T> *p=head;
        while(p!=NULL)
        {
            Node<T> *q=p;
            p=p->next;
            delete q;
        }
        head=NULL;
    }
    复制代码

     

  5. 单链表的插入操作，单链表不像顺序表，对与表的插入和删除很简单：
    1. 空表插入/头插入 
      Node<T> *q=NULL;
          if(head==NULL||i<0)//头插入(单链表为空或者)
          {
              q=new Node<T>(x,head);
              head=q;
          }
    2. 中间插入/尾插入 
      p->next=new Node<T>(x,p->next);
    单链表insert()以及参数构造函数：
    复制代码 
    template<class T>
    Node<T>* SinglyLinkedList<T>::insert(int i,T x)
    {
        Node<T> *q=NULL;
        if(head==NULL||i<0)//头插入(单链表为空或者)
        {
            q=new Node<T>(x,head);
            head=q;
        }
        else
        {
            int j=0;
            Node<T> *p=head;
            while(p->next!=NULL&&j<i-1)
            {
                j++;
                p=p->next;
            }
            q=new Node<T>(x,p->next);
            p->next=q;
        }
        return q;
    }

    template<class T>
    SinglyLinkedList<T>::SinglyLinkedList(T table[],int n)
    {
        head=NULL;
        if(n>0)
        {
            head=new Node<T>(table[0]);//创建节点
            Node<T> *rear=head;//创建一个指向头节点的指针
            int i=1;
            while(i<n)
            {
                rear->next=new Node<T>(table[i++]);
                rear=rear->next;
            }
        }
    }
    复制代码
  6. 单链表的删除操作也分两类：
    1. 头删除 
      Node<T> *q=head;
      head=head->next;
      delete q;
    2. 中间/尾删除 
      Node<T> *q=p->next;
      if(q!=NULL)//判断删除节点
      {
          p->next=q->next;//让删除节点的前驱Next指针下一节点
          delete q;//删除该节点
      }
    单链表的删除函数remove（）实现：
    复制代码 
    template<class T>
    bool SinglyLinkedList<T>::remove(int i,T &old)
    {
        if(i<0||head==NULL)
        {
            Node<T> *q=head;
            old=q->data;
            head=head->next;
            delete q;
        }
        else
        {
            Node<T> *p=getNode(i-1);//获取删除节点的前驱
            if(p!=NULL&&p->next!=NULL)//判断删除节点和删除节点是否为空
            {
                Node<T> *q=p->next;//新建一个节点指针，将删除接点复制过去
                old=q->data;
                p->next=q->next;//让删除节点的前驱Next指针下一节点
                delete q;//删除该节点
                    return true;
            }
        }
        return false;
    }
    复制代码
  7. 单链表的链接函数：concat()
    复制代码 
    template<class T>
    void SinglyLinkedList<T>::concat(SinglyLinkedList<T> &list)
    {
        if(this->head==NULL)
        {
            this->head=list->head;
        }
        else
        {
            Node<T> *p=head;
            while(p->next!=NULL)
            {
                p=p->next;
            }
            p=list->head;
        }
        list->head=NULL;//设置单链表为空，否则运行出错
    }
    复制代码

以上对C++单链表的分析 添加一个学生结构和一个测试函数：

Student.h

复制代码 
struct Student
{
    char number[10]; //学号
    char name[20]; //姓名
    double score; //得分
    friend std::ostream& operator<<(std::ostream& out,Student &stu)
    {
        out<<"学号："<<stu.number<<"  姓名："<<stu.name<<"  得分："<<stu.score;
        return out;
    }
};
复制代码

 主函数：

复制代码 
#include<iostream>
#include "SinglyLinkedList.h"
#include "Student.h"
void _TestToSinglyLinkedList()
{
    Student data[]={{"090313018","Silvester",45.4},{"090313018","捐赠",45.4},{"090313018","版主",45.6}};
    SinglyLinkedList<Student> m(data,3);
    Student t;
    std::cout<<(m.isEmpty()?"不为空！":"该链表为空！")<<std::endl;
    std::cout<<"长度："<<m.length()<<std::endl;
    std::cout<<"移除2个学生"<<m.remove(1,t)<<std::endl;
    std::cout<<"t:"<<t<<std::endl;
    std::cout<<"2个学生信息"<<m.getNode(1)<<std::endl;
    Student s={"415646","fdsfs",453.1};
    std::cout<<m.get(1)<<m.set(1,s)<<m.insert(5,s)<<std::endl;
}
void main()
{
    _TestToSinglyLinkedList();
    system("pause");
}
复制代码

C/C++ 创建一个节点Node算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-03 496
错误处理：在创建节点的过程中，可能会出现错误，需要进行适当的错误处理，以防止程序崩溃或出现其他异常情况。灵活性：创建一个节点的算法可以适用于不同的数据结构和应用场景，因为节点是数据结构中的基本单位。灵活性：创建一个节点的算法可以适用于不同的数据结构和应用场景，因为节点是数据结构中的基本单位。灵活性：创建一个节点的算法可以适用于不同的数据结构和应用场景，因为节点是数据结构中的基本单位。灵活性：创建一个节点的算法可以适用于不同的数据结构和应用场景，因为节点是数据结构中的基本单位。
c语言中node是数据类型吗,lnode(数据结构lnode是什么类型)
weixin_32916125的博客
05-23 2万+
请问LNode在C语言中代表什么，英语全称是什么是数据结构中定义链表的英文名称，代表链表中的结点， 可以查阅c中链表那一章的相关内容.数据结构Lnode *是代表什么！？？大侠 谢谢！！是一个 指针类型是吗？？？.你好！再清楚一些 Lnode应该是 结构、枚举、共用体、自定义类型等 (要看程序怎么定义的) Lnode*表示相应的结构指针或其它的指针 从命名方式来看 应该是.typedef stru...
C++实现单向链表的增加、删除、读取功能
HHHUANG
04-05 2380
链表相比于数组的优势有： 1. 增加和删除元素效率非常高； 2. 可以不需要预先知道存储元素的数量。 相比于数组的劣势有： 1. 查找元素的效率低； 2. 由于存储额外节点指针，带来的空间消耗。 采用C语言形式实现插入和删除两个函数 //插入元素 bool InsertNode(Node* p, int index, int data) { Node* pCur = p; ...
C++结构体基础（STRUCT）
最新发布
zaqplmfsderwqrdf的博客
11-01 627
C++结构体 (STRUCT)
node.js简单理解
qac的博客
12-11 583
2020.12.11 02:33 文章目录01.node.js究竟是什么?02.Node.js与JavaScript的区别是什么？03.Node.js的优点？Node.js的缺点？04.Node.js适用场景？Node.js不适用的场景？05.node.js于java和区别06.node.js于php的区别 01.node.js究竟是什么? Node.js是一个Javascript运行环境(runtime) 02.Node.js与JavaScript的区别是什么？ 本质： Javascript是一种we
C++中的节点类与链表类及链表操作
Vergesson
03-03 5925
链表能使人随时方便的插入删除元素，不太影响其他元素。 .顺序访问的线性群体——链表类 1、链表是一种动态数据结构，可以 用来表示顺序访问的线性群体（即你无法像数组那样通过下标灯光方式直接访问元素，需得知开始坐标往下找）。 2、链表是由系列节点组成的，节点可以在运行时动态生成。 3、每一个节点包括数据域和指向链表中下一个节点的指针（即下一个节点的地址，需要依赖它维持节点与节点间的次序关系）。如果链表每个节点中只有一个指向后继节点的指针，则该链表称为单链表。 注： 在使用数组的时候，我们是靠数组的物理地址的次序
c++算法系列-链表
weixin_44678052的博客
10-17 589
从今天开始，我就开始了算法的学习。也将学习的东西分享给大家。有不足的地方也希望大家指出。 一. 链表简介 一个班级能最大容纳50人，如果用数组来储存的话，就要定义一个大小为50的数组来储存。但是如果班级没有50人呢？只有25人呢？这样就会造成内存的浪费。又遇到班级扩张，最大人数扩张到100人呢？这样又会造成内存不足。这是数组的两大缺点。 为了解决数组的不足，于是我们设计了一种新的数据结构–链表...
数据结构C++ 单链表的实现 .cpp和.h文件
01-21
单链表是一种简单但重要的数据结构，它在C++编程中有着广泛的应用。本篇将深入探讨如何使用C++实现单链表，包括链表的建立、遍历、查找和删除操作。 首先，`LinkList.cpp`文件通常包含单链表类的实现，可能包括构造...
数据结构C++单链表冒泡法排序
12-06
数据结构，单链表冒泡法排序数据结构，C++实现，可输入式程序
数据结构C++单链表的头插法和尾插法
weixin_74453229的博客
05-16 1117
这个代码的存在的意义就是定义一个整形变量，有人会问整形变量不是int吗，你怎么用的Element，这里我在说明一下，这里也是考研的重点其中typedef int Element是为了在以后需要更改数据类型的时候方便更改，相当于就是将int 重命名为了Element.（请考研的各位同学务必记住）//这个指针的作用是指向申请的新的节点，一定要对不画图的读者说明，申请的这个指针是为了指向新的节点。这个代码的存在的意义就是头指针指向头结。这个代码的存在的意义就是头结点的下一个指针指向空NULL的意思就是空。
数据结构C++单链表详细操作实现(输入命令式)
12-06
单链表详细操作："1:创建单链表" "2:输出单链表中的元素" "3:按值查找元素" "4:按位置查找元素" "5:插入元素到单链表里" "6:删除链表中的某个结点" "7.退出
C/C++数据结构之单链表
2301_80102396的博客
07-29 1550
显然这里要使得实参的头节点在链接一个节点，就是使得实参改变，它本身就是一个指针，所以形参我们就需要二级指针来接受实参，进行传址来改变实参。思路：头删比较简单，我们只需要把头节点的下一个节点用一个变量储存起来，然后我们把头节点释放，然后把头节点指向我们刚才变量存起来的那个地址即可；我们next是结构体类型指针，因为我们的next指向的是下一个节点，下一个节点也是结构体，所以我们需要使用结构体类型指针。在进行基本操作前提都是需要节点的，所以我们能将开辟节点的操作写为一个函数，这样在每次使用前调用即可。
c++数据结构-树（详细总结附代码，一看就懂）
我的博客
01-19 8063
一棵树是由n（n>0）个元素组成的有限集合，其中：（1）每个元素称为结点（node）（2）有一个特定的结点，称为根结点或树根（root）（3）除根节点外，其余节点能分成m（m>=0）个互不相交的有限集合 T(0)-T(m-1)。其中的每一个子集都是一个树，这些集合被称为这棵树的子树。
Node.js 15 正式版发布
xiangzhihong8的专栏
10-22 4884
前两天，Node.js官方发布了Node.js 15的正式版本，Node.js 15 将替代 Node.js 14 成为当前的的稳定发行版，后者将在本月晚些时候升级为 LTS（长期支持）版本。如果大家想体验下Node.js 15 的最新功能，可以从官方进行下载。 那Node.js 15带来了哪些新的功能和特性呢？主要体现在以下几个方面： AbortController N-API 版本 7 npm 7 unhandled rejections 默认抛出 QUIC V8 8.6 AbortControl
[C++]试一试结构体struct node的构造函数
热门推荐
11-09 2万+
完全不懂计算机原理的人举爪
c语言node类型_Node进阶探究不在V8堆内存中存储的Buffer对象
weixin_39914107的博客
11-27 164
## 前言 写完上一篇文章想学Node.js，stream先有必要搞清楚留下了悬念， stream对象数据流转的具体内容是什么？本篇文章将为大家进行深入讲解。Buffer探究看一段之前使用 stream操作文件的例子：var fileName = path.resolve(__dirname, 'data.txt');var stream=fs.createReadStream(file...
关于c和c++中的struct类型
自由翱翔
09-26 640
    c 语言中的struct类型和c＋＋中的class很类似，那么它们你之间到底有什么区别呢？  c语言中的struct类型在默认情况下是public，而class在默认情况下却是private类型。不知你曾经是否思考过关于在struct中是否可以和class中能否定义函数的问题。     struct是不能定义函数的，应为函数不是一个对象。在c99中Rationale精辟的指出所有c中对象的
数据结构C++实现单链表以及各种操作！
qq_58240448的博客
06-30 3144
使用c++实现的单链表以及各种操作，入插入、删除等！
C++ 双链表基本操作
qq_40423330的博客
05-18 333
双链表基本操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值