C++单链表的初始化，插入，删除，反转操作

最新推荐文章于 2025-09-15 09:13:48 发布
原创 最新推荐文章于 2025-09-15 09:13:48 发布 · 2.5w 阅读 · 100 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++单链表 #链表的基本操作 #单链表的反转 #C++ #链表

本文深入解析链表的基本操作，包括初始化、节点插入、节点删除以及链表的倒序输出。通过实例代码，详细阐述了每个操作的实现过程，帮助读者理解链表在数据结构中的应用。

链表的性质：

1.元素不能随机访问

2.链表只有一个表头

3.元素相互依赖，串联而成

链表的初始化：

#include<iostream>
using namespace std;
//节点类
class Node{
public:
    int data;       //数据域
    Node *next;     //指向下一个节点的指针
    Node(int _data){  //显式构造函数,每次对新声明的节点类的对象进行初始化
        data = _data;
        next = NULL;
    }
};
//链表类
class LinkList{
public:
    LinkList (){
        head = NULL;    //显式构造函数,每次对新声明的链表类进行初始化,即表示
                        //创建一个新的"空"链表,链表中只有头指针,并且头指针的值为NULL,表示头指针
                        //指向的部分也无任何数据元素
    }
    void Insert(Node *node,int position);
    void Output();
private:
    Node *head;    //设置为类的私有成员,只有通过类的成员函数才能访问
};


链表的插入操作以及链表节点的遍历：

                //C++形式的链表的插入,遍历输出，链表倒序等操作
#include<iostream>
using namespace std;
//节点类
class Node{
public:
    int data;       //数据域
    Node *next;     //指向下一个节点的指针
    Node(int _data){  //显式构造函数,每次对新声明的节点类的对象进行初始化
        data = _data;
        next = NULL;
    }
};
//链表类
class LinkList{
public:
    LinkList (){
        head = NULL;    //显式构造函数,每次对新声明的链表类进行初始化,即表示
                        //创建一个新的"空"链表,链表中只有头指针,并且头指针的值为NULL,表示头指针
                        //指向的部分也无任何数据元素
    }
    void Insert(Node *node,int position);
    void Output();
private:
    Node *head;    //设置为类的私有成员,只有通过类的成员函数才能访问
};
void LinkList::Insert(Node *node,int position){     //position表示要插入的位置
            if(head==NULL){              //在头指针为空指针的情况下,链表是空的,无任何数据元素
                                        //包括头结点在内.因此呢,我们在插入节点的时候,如果发现头结点为空指针
                head = node;             //的情况,那么这就意味着我们插入的这个节点要将其设置为头结点,
                return;                 //而后一一插入的节点则接在该节点的后方,并且通过这个节点从头开始遍历
                                        //能够遍历到链表中所有的数据元素


            }
            if(position==0){      //插入的是第0个位置,为了方便，我们暂且规定头结点为第0个节点
                                  //那么如果插入的是第0个位置的话,说明插入的节点要成为新的头结点
                                  //而不管之前有没有头结点
            node -> next = head;
            head = node;          //完成头结点的更新,表示头结点现在是node节点
            return;

            }
            Node *current_node = head;     //从头结点开始遍历插入的位置
            int i = 0;                    //表示已经遍历过的节点数目
            while(current_node -> next != NULL && i < position-1){
                                                                //不断寻找要插入的位置的前一个位置,然后插入在这个位置的节点与下一个位置的节点之间
                current_node = current_node -> next;            //不断更新current_node的值
                i++;
            }
            if(i == position-1){            //找到了插入的位置，先更新插入节点的指针域,记录当前遍历到的位置的下一个节点
                                            //然后再接上前面的节点

                node -> next = current_node -> next;
                current_node -> next = node;
            }
}
void LinkList::Output(){
            if(head==NULL){
                return;       //链表为空链表,无任何数据元素可输出
            }
            Node *current_node = head;     //从头结点开始遍历
            while(current_node!=NULL){
                cout << current_node -> data << " ";
                current_node = current_node -> next;
            }
            cout << endl;
}
int main(){
    LinkList linkList;
    for(int i = 1;i <= 10;i++){
        Node *node = new Node(i);      //用new给链表的每一个节点开辟空间
        linkList.Insert(node,i-1);     //调用成员函数
    }
    linkList.Output();
    return 0;
}


链表的节点删除操作

                //C++形式的链表的插入,遍历输出，链表倒序等操作
#include<iostream>
using namespace std;
//节点类
class Node{
public:
    int data;       //数据域
    Node *next;     //指向下一个节点的指针
    Node(int _data){  //显式构造函数,每次对新声明的节点类的对象进行初始化
        data = _data;
        next = NULL;
    }
};
//链表类
class LinkList{
public:
    LinkList (){
        head = NULL;    //显式构造函数,每次对新声明的链表类进行初始化,即表示
                        //创建一个新的"空"链表,链表中只有头指针,并且头指针的值为NULL,表示头指针
                        //指向的部分也无任何数据元素
    }
    void Insert(Node *node,int position);
    void Output();
    void delete_node(int delete_position);
private:
    Node *head;    //设置为类的私有成员,只有通过类的成员函数才能访问
};
void LinkList::Insert(Node *node,int position){     //position表示要插入的位置
            if(head==NULL){              //在头指针为空指针的情况下,链表是空的,无任何数据元素
                                        //包括头结点在内.因此呢,我们在插入节点的时候,如果发现头结点为空指针
                head = node;             //的情况,那么这就意味着我们插入的这个节点要将其设置为头结点,
                return;                 //而后一一插入的节点则接在该节点的后方,并且通过这个节点从头开始遍历
                                        //能够遍历到链表中所有的数据元素


            }
            if(position==0){      //插入的是第0个位置,为了方便，我们暂且规定头结点为第0个节点
                                  //那么如果插入的是第0个位置的话,说明插入的节点要成为新的头结点
                                  //而不管之前有没有头结点
            node -> next = head;
            head = node;          //完成头结点的更新,表示头结点现在是node节点
            return;

            }
            Node *current_node = head;     //从头结点开始遍历插入的位置
            int i = 0;                    //表示已经遍历过的节点数目
            while(current_node -> next != NULL && i < position-1){
                                                                //不断寻找要插入的位置的前一个位置,然后插入在这个位置的节点与下一个位置的节点之间
                current_node = current_node -> next;            //不断更新current_node的值
                i++;
            }
            if(i == position-1){            //找到了插入的位置，先更新插入节点的指针域,记录当前遍历到的位置的下一个节点
                                            //然后再接上前面的节点

                node -> next = current_node -> next;
                current_node -> next = node;
            }
}
void LinkList::Output(){
            if(head==NULL){
                return;       //链表为空链表,无任何数据元素可输出
            }
            Node *current_node = head;     //从头结点开始遍历
            while(current_node!=NULL){
                cout << current_node -> data << " ";
                current_node = current_node -> next;
            }
            cout << endl;
}
void LinkList::delete_node(int delete_position){
           if(head==NULL){
                return;       //链表为空链表,无任何数据元素可删除
            }
           Node *current_node = head;     //从头结点开始遍历删除的位置
           int i = 0;                    //表示已经遍历过的节点数目
           if(delete_position==0){
                 head = head->next;     //删除的是第0个节点,即删除的是头结点,那么新的头结点即为
                                       //第一个节点
                 delete current_node;   //删除原来头结点申请的内存,防止内存泄漏
                 return;
           }
           while(current_node -> next != NULL && i < delete_position-1){
                                                                //不断寻找要删除的位置的前一个位置,然后插入在这个位置的节点与下一个位置的节点之间
                current_node = current_node -> next;            //不断更新current_node的值
                i++;
            }
            if(i == delete_position-1){            //找到了删除的位置
                Node *delete_node = current_node -> next;     //delete_node用于记住需要删除的节点的地址
                current_node -> next = current_node -> next -> next;
                delete delete_node;      //同样是将申请的内存归还给系统,防止内存泄漏
            }

}
int main(){
    LinkList linkList;
    for(int i = 1;i <= 10;i++){
        Node *node = new Node(i);      //用new给链表的每一个节点开辟空间
        linkList.Insert(node,i-1);     //调用成员函数
    }
    linkList.Output();
    linkList.delete_node(9);     //总共10个节点,i==1时为头结点,后九个节点一一接在头结点之后
    linkList.Output();
    return 0;
}





链表的倒序输出（即原来链表中各数据域存储的依次是1,2,3,4,5,6,7,8,9,10）

而倒序是将原来的头结点变成尾节点，原来的尾节点变成头结点。

倒序后将输出（10,9,8,7,6,5,4,3,2,1）

首先，链表的倒序的概念上面已经描述清楚了，首先我们应该清楚实现链表反转我们需要做哪些步骤？

1.断线(除尾节点外的所有节点都要“断线”)

2.加线(除头结点外的所有节点都要”加线“)

3.处理的节点前移一个，然后再重复1,2步骤，直到处理的节点为NULL，表示链表全部处理完毕

一开始，我们要知道的是，原来的头结点变成了尾节点，并且一开始是处理头结点。所以呢，原来的头结点的指针域应该为NULL，这样的话头结点与第一个节点便断开了，

然后便是“加线”，（线箭头的指向与原来链表的相反）加线是从第一个节点开始处理，于是我们声明一个current_node指针指向当前处理到的节点。

由于"加线"的是要将当前处理到的节点的指针域指向“断线”的节点（例如在第一个节点的“加线”操作中就是current_node -> next = head,即是第一个节点指向原来的头结点）

但是如果这样的话，当前节点便与之后的节点全部断开（原因是原来当前节点记录的是其下一个节点的地址，也就是说第一个节点记录的是第二个节点的地址），使得链表反转操作无法继续进行，所以呢，我们自然而然的就想到了再声明一个指向Node类型的next_node指针，使其先记住当前操作到的节点之后的节点的地址，即next_node = current_node -> next，这样的话，等到下一次操作的时候，直接将next_node的地址赋给current_node就好了。（表示指针前移）

然后在这期间要不断地更新头结点，因为我们可以不管链表有多长，但是呢，我们每操作一次，比如说是操作到第一个节点，使其指向头结点，那么这时候新的“头结点”就是第一个节点了，后面的话以此类推，直到操作完毕。

完整代码实现：

                //C++形式的链表的插入,遍历输出，链表倒序等操作
#include<iostream>
#include<cstdlib>
using namespace std;
//节点类
class Node{
public:
    int data;       //数据域
    Node *next;     //指向下一个节点的指针
    Node(int _data){  //显式构造函数,每次对新声明的节点类的对象进行初始化
        data = _data;
        next = NULL;
    }
};
//链表类
class LinkList{
public:
    LinkList (){
        head = NULL;    //显式构造函数,每次对新声明的链表类进行初始化,即表示
                        //创建一个新的"空"链表,链表中只有头指针,并且头指针的值为NULL,表示头指针
                        //指向的部分也无任何数据元素
    }
    void Insert(Node *node,int position);
    void Output();
    void Reverse_order();
private:
    Node *head;    //设置为类的私有成员,只有通过类的成员函数才能访问
};
void LinkList::Insert(Node *node,int position){     //position表示要插入的位置
            if(head==NULL){              //在头指针为空指针的情况下,链表是空的,无任何数据元素
                                        //包括头结点在内.因此呢,我们在插入节点的时候,如果发现头结点为空指针
                head = node;             //的情况,那么这就意味着我们插入的这个节点要将其设置为头结点,
                return;                 //而后一一插入的节点则接在该节点的后方,并且通过这个节点从头开始遍历
                                        //能够遍历到链表中所有的数据元素


            }
            if(position==0){      //插入的是第0个位置,为了方便，我们暂且规定头结点为第0个节点
                                  //那么如果插入的是第0个位置的话,说明插入的节点要成为新的头结点
                                  //而不管之前有没有头结点
            node -> next = head;
            head = node;          //完成头结点的更新,表示头结点现在是node节点
            return;

            }
            Node *current_node = head;     //从头结点开始遍历插入的位置
            int i = 0;                    //表示已经遍历过的节点数目
            while(current_node -> next != NULL && i < position-1){
                                                                //不断寻找要插入的位置的前一个位置,然后插入在这个位置的节点与下一个位置的节点之间
                current_node = current_node -> next;            //不断更新current_node的值
                i++;
            }
            if(i == position-1){            //找到了插入的位置，先更新插入节点的指针域,记录当前遍历到的位置的下一个节点
                                            //然后再接上前面的节点

                node -> next = current_node -> next;
                current_node -> next = node;
            }
}
void LinkList::Output(){
            if(head==NULL){
                return;       //链表为空链表,无任何数据元素可输出
            }
            Node *current_node = head;     //从头结点开始遍历
            while(current_node!=NULL){
                cout << current_node -> data << " ";
                current_node = current_node -> next;
            }
            cout << endl;
}
void LinkList::Reverse_order(){
           if(head==NULL){
                return;       //链表为空链表
            }
            Node *current_node = head -> next,*next_node;     //从头结点开始遍历
            head -> next = NULL;
            while(current_node != NULL){
                next_node = current_node -> next;    //记住当前操作节点的后面节点的地址
                current_node -> next = head;
                head = current_node;
                current_node = next_node;
            }
}
int main(){
    LinkList linkList;
    for(int i = 1;i <= 10;i++){
        Node *node = new Node(i);      //用new给链表的每一个节点开辟空间
        linkList.Insert(node,i-1);     //调用成员函数
    }
    linkList.Output();
    linkList.Reverse_order();
    linkList.Output();
    return 0;
}


由于在数据结构课程中已经有学过链表的相关内容，因此其他各式各样的链表详细的基本操作便不再补充,只简要的说明一下其他链表的一些性质

1.双向链表，也叫双链表。单链表里的指针域只记录了结点的下一个结点，也就是后继结点，而双向链表的指针域同时还记录了结点的上一个结点，也就是前驱结点。有了这样的结构，我们可以从头结点遍历到尾结点，也可以从尾结点遍历到头结点了。


注意双链表与单链表的区别：

双向链表的指针域有两个指针，一个指向后继，一个指向前驱

而单链表的指针域只有一个指向后继节点的指针

2.循环链表。相比单链表，循环链表是将最后一个结点的指针指向头结点，这样使得链表更加灵活方便。循环链表里没有空指针，所以在判断结束条件时，不再是判断指针是否为空，而是判断指针是否等于某固定指针。另外，在单链表里只能访问到后面的结点，而在循环链表里可以访问到所有的结点。


注意循环链表的问题：

1.循环链表遍历时只能用结点是否等于某一结点判断结束

2.循环链表可以访问到任意结点



如有错误，还请指正，O(∩_∩)O谢谢


c++ 单链表的初始化，插入，查找，删除操作
qq_45926226的博客
10-24 2718
#include using namespace std; typedef struct LNode { int data; LNode* next; }LNode,Linklist; //初始化一个空表 //bool InitList(Linklist &L) { // L = NULL; // return true; //} //判断单链表是否为空 //bool Empty(Linklist L) { // return(L == NULL); //} //初始化一个带头结点的单链表 bool
初始化链表C++实现
Li_XiQiong的博客
11-21 4200
class List{ public： void init(){} private: struct Node { int data; Node * next; Node(const int& d) :data(d), next(NULL) {}
数据结构单链表初始化c/c++语言代码实现
01-22
很多刚接触数据结构的小白在学完单链表，只知道理论知识，却不知道如何实现，这是用c++语言实现的两种单链表初始化过程
链表初始化C++
cherry-keven
05-13 3916
#include <iostream> using namespace std; //节点类 class Node { public: int data; //数据域 Node *next; //指向下一个节点的指针 Node(int _data) { //显式构造函数,每次对新声明的节点类的对象进行初始化 data = _data; next = NULL; } }; //链表类 class LinkList { publi
链表【C++数据结构】
最新发布
不会C++、害怕嵌入式且不爱看动漫的小趴菜
09-15 1万+
本文系统讲解链表指针原理与实现，对比std::list和vector，并深入分析了其在频繁插入/删除场景（如LRU缓存）下的独特性能优势与应用价值。
C++单链表基本操作初始化、创建、增、删、查等
weixin_66549669的博客
07-11 800
#include #include #define ERROR 0 #define OK 1 typedef int ElemType; using namespace std; typedef struct LNode { ElemType data; struct LNode* next; }LNode,*LinkList; int InitList(LinkList &L) { L=new LNode;//或L=(LinkList)ma
C++ 单向链表 —— 初始化、插入、返回第一个节点、删除、查找、长度、打印、反转(逆序)
辛旭东小小工作室
03-15 3120
单向链表的概念： 如果“一个节点”将指向“另一个节点的指针”作为数据成员，那么多个这样的节点可以连起来，只用一个变量就能够访问整个节点序列，我们称之为链表。如果序列中的节点只包含指向后继节点的链接，该链表就称之为单向链表。 01 声明： #ifndef LINKLIST_H #define LINKLIST_H #include <iostream> using name...
单链表的创建、插入、删除
09-22
本文将详细介绍单链表的基本操作：创建、插入和删除。单链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含两部分：存储数据的数据域和指向下一个节点的指针域。 #### 单链表创建 单链表的创建可以...
C++实现单链表基础操作：插入、查找、逆置与删除
本资源主要介绍了单链表在C++中的各种操作实现，包括但不限于插入、查找、逆置和删除。单链表是一种基础的数据结构，它由节点组成，每个节点包含数据域和指向下一个节点的指针。以下将详细讲解这些操作的实现方法。 ...
C++实现单链表的16种基本操作
weixin_47373497的博客
10-29 2717
C++实现单链表的16种基本操作 链表初始化，头插法创建链表，尾插法创建链表，取值，查找（第i个节点的数据域或者数据域为某个特定值的节点），有顺序的合并两个链表，无顺序的合并两个链表，插入，删除，逆置链表，求链表的节点个数，删除数据域重复的节点，输出链表，判空，置空链表。 以下是我写的头文件的代码 #ifndef DANLIANBIAO_H #define DANLIANBIAO_H #endif #include<iostream> #include<stdio.h> #inclu
C++单链表操作：逆序建立与增删技巧
本知识点将详细介绍如何用C++实现带头结点的单链表，并且涉及到逆序建立链表、插入和删除等基本操作。 首先，单链表是一种线性表的链式存储结构。在单链表中，每个节点包含两个部分：一个是存储数据元素的值，另一...
C++实现单链表(初始化指定长度的单链表)
鑫宇的博客
12-14 2708
#include <stdio.h> #include <malloc.h> typedef struct SNode { // 数据域 int data; // 指针域 struct SNode *next; } * PNode, Node; // PNode=struct SNode* Node=struct SNode // 初始化一个链表 PNode init_list(); // 插入元素 bool insert(PNode, int, int); /
C++链表初始化（头结点分配内存）
weixin_53323037的博客
08-05 495
通过InitList1函数为链表分配头结点内存，若内存分配成功，将头结点的next指针置为空表示链表为空。在InitList1函数中，对内存分配失败的情况进行了恰当处理，返回ERROR状态。
C++构造函数的初始化链表
Gerald的博客
03-16 5590
构造函数的初始化链表 1.构造函数体赋值 在我们创建对象的时候，编译器会自动调用构造函数给创建的对象中各个成员变量一个合适的初始值。 例如下面的代码： class Date { public: Date(int year, int month, int day) { _year = year; //_year = 1997; _month = month; ...
链表（C++）
2401_87345428的博客
03-29 1617
这是本人第二次学习链表，第一次学习链表是在大一上的C语言课上，首次接触，感到有些难；第二次是在大一下学习数据结构时（就是这次），使用C++再次理解链表。同时，这也是开启数据结构学习写的第一篇文章，但愿以后有时间一直写下去。当然，学习数据结构还是保持着学习计算机的基本素养——增、删、查、改。
【C++链表】
W_Oilpicture的博客
09-03 793
链表是有一系列结点组成的，每个结点包括两个部分：1、存储数据元素的数据域；2、存储下一个节点地址的指针域。int val;} };
【C++ 链表】
qq_45602618的博客
07-15 275
反转链表1（LeetCode 206.） class Solution { public: ListNode* reverseList(ListNode* head) { ListNode *new_head = NULL; while(head){ ListNode *next = head->next; head->next = new_head; new_head = hea.
C++的链表
weixin_64558254的博客
05-27 613
由于c++没有LinkedList，要用链表很不方便，所以我就自己写了个，思路是把链表的每个结点放到数组里。 需要可以直接复制去用。 目前只有add添加，show输出链表，reverse倒置链表 三个功能，有需要的留言，我把剩下的增删查改也写了。 #include<iostream> using namespace std; class Node { public: Node* pre; string value; Node* next; static ...
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值