C++实现单链表的基本操作

已于 2022-12-28 11:48:19 修改
阅读量1k 收藏 10
点赞数 2
分类专栏： 数据结构 c++刷LeetCode 文章标签： c++ 数据结构
于 2022-12-27 20:50:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaicheng55/article/details/128461313
版权

文章目录

单链表节点结构体

struct ListNode {
      int val;										//数据域
      ListNode *next;								//指针域
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };

链表遍历输出（方便测试）

void Print_LinkNode(ListNode* head) {
    ListNode* p = head;
    while(p != nullptr) {
        p = p -> next;
        cout << p -> val;
        if(p -> next != nullptr)
            cout  << " -> ";
    }
}

一、头结点插入法创建单链表

ListNode* List_Head_insert() {
    ListNode* head = new ListNode();
    int x;
    cin >> x;
    while(x != 666) {//输入666结束链表的创建

        ListNode* newnode = new ListNode(x);
        newnode -> next = head -> next;
        head -> next = newnode;

        cin >> x;
    }
    return head;
}
头插法测试代码
#include<iostream>	//strin and stdout 的头文件
using namespace std;

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };

// 头结点插入法
ListNode* List_Head_insert() {
    ListNode* head = new ListNode();
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        newnode -> next = head -> next;
        head -> next = newnode;

        cin >> x;
    }
    return head;
}

void Print_LinkNode(ListNode* head) {
    ListNode* p = head;
    while(p != nullptr) {
        p = p -> next;
        cout << p -> val;
        if(p -> next != nullptr)
            cout  << " -> ";
    }
}

int main() {
    ListNode* head = List_Head_insert(); //倒序插入不推荐
    Print_LinkNode(head);
}

输入

1
2
3
4
5
666

输出

5 -> 4 -> 3 -> 2 -> 1

二、尾结点插入法创建单链表

ListNode* List_Tail_insert() {
    ListNode* head = new ListNode();
    ListNode* p = head;
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        p -> next = newnode;
        p = p -> next;  // p = newnode;

        cin >> x;
    }
    return head;
}
尾插法测试代码
#include<iostream>	//strin and stdout 的头文件
using namespace std;

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };

// 尾结点插入法
ListNode* List_Tail_insert() {
    ListNode* head = new ListNode();
    ListNode* p = head;
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        p -> next = newnode;
        p = p -> next;  // p = newnode;

        cin >> x;
    }
    return head;
}

void Print_LinkNode(ListNode* head) {
    ListNode* p = head;
    while(p != nullptr) {
        p = p -> next;
        cout << p -> val;
        if(p -> next != nullptr)
            cout  << " -> ";
    }
}

int main() {
    ListNode* head = List_Tail_insert();//正序插入
    Print_LinkNode(head);
}

输入

1
2
3
4
5
666

输出

1 -> 2 -> 3 -> 4 -> 5

三、按序号查找

//按序号查找(输入有序号一定不要忘记非法输入检验与序号越界检验！！！)
ListNode* Selectbyindex(int index,ListNode* head) {
    if(index < 1)return nullptr;    //非法输入检查不能忘！
    ListNode* p = head -> next;     //尽量不要改变输入的指针域
                                    //有头结点！！要从第一个元素开始head -> next！！！
    int i = 1;
    while(p != nullptr && i < index) {  //防止index超过链表长度要进行非空检验!

        p = p -> next;
        i++;

    }
    return p;
}
按序号查找测试代码
#include<iostream>	//strin and stdout 的头文件
using namespace std;

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };

// 头结点插入法
ListNode* List_Head_insert() {
    ListNode* head = new ListNode();
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        newnode -> next = head -> next;
        head -> next = newnode;

        cin >> x;
    }
    return head;
}

//按序号查找(输入有序号一定不要忘记非法输入与序号越界检验！！！)
ListNode* Selectbyindex(int index,ListNode* head) {
    if(index < 1)return nullptr;    //非法输入检查不能忘！
    ListNode* p = head -> next;     //尽量不要改变输入的指针域
                                    //有头结点！！要从第一个元素开始head -> next！！！
    int i = 1;
    while(p != nullptr && i < index) {  //防止index超过链表长度要进行非空检验!

        p = p -> next;
        i++;

    }
    return p;
}


int main() {
	int index;
	ListNode* head = List_Tail_insert();//正序插入
    cout << "请输入要查询的节点序号" <<endl;
    cin >> index;
    ListNode* res = Selectbyindex(index,head);
    cout << res -> val;
}

输入

1
5
3
6
7
666
2

输出

5

四、按值查找

//按值查找
ListNode* Selectbyvalue(int value,ListNode* head) {
    ListNode* p = head -> next;
    while(p != nullptr && p -> val != value) { //每次都能取出val值，不需要再加中间变量保存每一次的val了！！

        p = p -> next;

    }
    return p;
}
按值查找测试代码
#include<iostream>	//strin and stdout 的头文件
using namespace std;

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };

// 头结点插入法
ListNode* List_Head_insert() {
    ListNode* head = new ListNode();
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        newnode -> next = head -> next;
        head -> next = newnode;

        cin >> x;
    }
    return head;
}

//按值查找
ListNode* Selectbyvalue(int value,ListNode* head) {
    ListNode* p = head -> next;
    while(p != nullptr && p -> val != value) { //每次都能取出val值，不需要再加中间变量保存每一次的val了！！

        p = p -> next;

    }
    return p;
}

int main() {
    int value;
	ListNode* head = List_Tail_insert();//正序插入
    cout << "请输入要查询的节点的值" <<endl;
    cin >> value;
    ListNode* res = Selectbyvalue(value,head);
    cout << res -> val;
}

输入

1
5
3
6
7
666
5

输出

5

五、按序号插入

//按序号插入
void Insertbyindex(int index,ListNode* head,ListNode* node) {
    if(index < 1)return;
    //采用后插法
    ListNode* p = head;//若插入第一个序号的位置，为了保证其有前驱节点要从head开始而不是head -> next
    int i = 0;//相应的i改成0开始而不是1
    while(p != nullptr) {
        if(i == index - 1){
        
            //通常采用的是后插法，需要找到插入位置的前驱节点来后插
            //前插法与之相反，但可以将对节点的前插操作转化为后插操作，即找到节点的前节点后插。
            node -> next = p -> next;
            p -> next = node;

        }

        //另一种后插实现前插的方法是，将node插入p的后面，再交换node和p的val。
        //if(i == index) {
        
            //node -> next = p -> next;
            //p -> next = node;
            //int temp = node -> val;
            //node -> val = p -> val;
            //p -> val = temp;

        //}

        p = p -> next;
        i++;
    }
}
按序号插入测试代码
#include<iostream>	//strin and stdout 的头文件
using namespace std;

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };

// 头结点插入法
ListNode* List_Head_insert() {
    ListNode* head = new ListNode();
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        newnode -> next = head -> next;
        head -> next = newnode;

        cin >> x;
    }
    return head;
}

//按序号插入
void Insertbyindex(int index,ListNode* head,ListNode* node) {
    if(index < 1)return;
    //采用后插法
    ListNode* p = head;//若插入第一个序号的位置，为了保证其有前驱节点要从head开始而不是head -> next
    int i = 0;//相应的i改成0开始而不是1
    while(p != nullptr) {
        if(i == index - 1){

            //通常采用的是后插法，需要找到插入位置的前驱节点来后插
            //前插法与之相反，但可以将对节点的前插操作转化为后插操作，即找到节点的前节点后插。
            node -> next = p -> next;
            p -> next = node;

        }

        //另一种后插实现前插的方法是，将node插入p的后面，再交换node和p的val。
        //if(i == index) {

            //node -> next = p -> next;
            //p -> next = node;
            //int temp = node -> val;
            //node -> val = p -> val;
            //p -> val = temp;

        //}

        p = p -> next;
        i++;
    }
}

void Print_LinkNode(ListNode* head) {
    ListNode* p = head;
    while(p != nullptr) {
        p = p -> next;
        cout << p -> val;
        if(p -> next != nullptr)
            cout  << " -> ";
    }
}

int main() {
    int index;
	ListNode* head = List_Tail_insert();//正序插入
    cout << "请输入要插入的节点序号" <<endl;
    cin >> index;
    ListNode* node = new ListNode(4);
    Insertbyindex(index,head,node);
    Print_LinkNode(head);
}

输入

1
2
3
5
666
4

输出

1 -> 2 -> 3 -> 4 -> 5

六、按序号删除

void Deletebyindex(int index,ListNode* head) {
    if(index < 1)return;
    //找到其前驱节点
    ListNode* p = head;//若删除第一个序号的位置，为了保证其有前驱节点要从head开始而不是head -> next
    int i = 0;//相应的i改成0开始而不是1
    while(p != nullptr) {
        找到前驱节点删除改节点
        if(i == index - 1) {

            ListNode* delnode = p -> next;
            p -> next = delnode -> next;
            free(delnode);//c++没有垃圾收集机制，要手动释放不用的堆内存，否则容易内存泄漏！

        }

        //另一种方法是找到该节点，将该节点值与后驱节点值替换，删除后驱节点。
        //if(i == index) {

            //ListNode* afternode = p -> next;
            //p -> next = afternode -> next;
            //p -> val = afternode -> val;
            //free(afternode);

        //}
        
        p = p -> next;
        i++;
    }
}
按序号删除测试代码
#include<iostream>	//strin and stdout 的头文件
#include<cstdlib>   //free的头文件
using namespace std;

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };
  
// 头结点插入法
ListNode* List_Head_insert() {
    ListNode* head = new ListNode();
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        newnode -> next = head -> next;
        head -> next = newnode;

        cin >> x;
    }
    return head;
}

void Deletebyindex(int index,ListNode* head) {
    if(index < 1)return;
    //找到其前驱节点
    ListNode* p = head;//若删除第一个序号的位置，为了保证其有前驱节点要从head开始而不是head -> next
    int i = 0;//相应的i改成0开始而不是1
    while(p != nullptr) {
        找到前驱节点删除改节点
        if(i == index - 1) {

            ListNode* delnode = p -> next;
            p -> next = delnode -> next;
            free(delnode);//c++没有垃圾收集机制，要手动释放不用的堆内存，否则容易内存泄漏！

        }

        //另一种方法是找到该节点，将该节点值与后驱节点值替换，删除后驱节点。
        //if(i == index) {

            //ListNode* afternode = p -> next;
            //p -> next = afternode -> next;
            //p -> val = afternode -> val;
            //free(afternode);

        //}
        
        p = p -> next;
        i++;
    }
}
void Print_LinkNode(ListNode* head) {
    ListNode* p = head;
    while(p != nullptr) {
        p = p -> next;
        cout << p -> val;
        if(p -> next != nullptr)
            cout  << " -> ";
    }
}

int main() {
    int index;
	ListNode* head = List_Tail_insert();//正序插入
    cout << "请输入要删除的节点序号" <<endl;
    cin >> index;
    ListNode* node = new ListNode(4);
    Deletebyindex(index,head);
    Print_LinkNode(head);
}

输入

1
2
3
4
5
666
3

输出

1 -> 2 -> 4 -> 5

汇总代码

#include<iostream>	//strin and stdout 的头文件
#include<cstdlib>   //free的头文件

using namespace std;

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}         //节点默认构造方法
      ListNode(int x) : val(x), next(nullptr) {}    //节点初始化val的构造方法
  };

// 头结点插入法
ListNode* List_Head_insert() {
    ListNode* head = new ListNode();
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        newnode -> next = head -> next;
        head -> next = newnode;

        cin >> x;
    }
    return head;
}

// 尾结点插入法
ListNode* List_Tail_insert() {
    ListNode* head = new ListNode();
    ListNode* p = head;
    int x;
    cin >> x;
    while(x != 666) {

        ListNode* newnode = new ListNode(x);
        p -> next = newnode;
        p = p -> next;  // p = newnode;

        cin >> x;
    }
    return head;
}

//遍历链表输出
void Print_LinkNode(ListNode* head) {
    ListNode* p = head;
    while(p != nullptr) {

        p = p -> next;
        cout << p -> val;
        if(p -> next != nullptr)
            cout  << " -> ";
    }
}

//按序号查找(输入有序号一定不要忘记非法输入与序号越界检验！！！)
ListNode* Selectbyindex(int index,ListNode* head) {
    if(index < 1)return nullptr;    //非法输入检查不能忘！
    ListNode* p = head -> next;     //尽量不要改变输入的指针域
                                    //有头结点！！要从第一个元素开始head -> next！！！
    int i = 1;
    while(p != nullptr && i < index) {  //防止index超过链表长度要进行非空检验!

        p = p -> next;
        i++;

    }
    return p;
}

//按值查找
ListNode* Selectbyvalue(int value,ListNode* head) {
    ListNode* p = head -> next;
    while(p != nullptr && p -> val != value) { //每次都能取出val值，不需要再加中间变量保存每一次的val了！！

        p = p -> next;

    }
    return p;
}

//按序号插入
void Insertbyindex(int index,ListNode* head,ListNode* node) {
    if(index < 1)return;
    //采用后插法
    ListNode* p = head;//若插入第一个序号的位置，为了保证其有前驱节点要从head开始而不是head -> next
    int i = 0;//相应的i改成0开始而不是1
    while(p != nullptr) {
        if(i == index - 1){

            //通常采用的是后插法，需要找到插入位置的前驱节点来后插
            //前插法与之相反，但可以将对节点的前插操作转化为后插操作，即找到节点的前节点后插。
            node -> next = p -> next;
            p -> next = node;

        }

        //另一种后插实现前插的方法是，将node插入p的后面，再交换node和p的val。
        //if(i == index) {

            //node -> next = p -> next;
            //p -> next = node;
            //int temp = node -> val;
            //node -> val = p -> val;
            //p -> val = temp;

        //}

        p = p -> next;
        i++;
    }
}

//按序号删除
void Deletebyindex(int index,ListNode* head) {
    if(index < 1)return;
    //找到其前驱节点
    ListNode* p = head;//若删除第一个序号的位置，为了保证其有前驱节点要从head开始而不是head -> next
    int i = 0;//相应的i改成0开始而不是1
    while(p != nullptr) {
        找到前驱节点删除改节点
        if(i == index - 1) {

            ListNode* delnode = p -> next;
            p -> next = delnode -> next;
            free(delnode);//c++没有垃圾收集机制，要手动释放不用的堆内存，否则容易内存泄漏！

        }

        //另一种方法是找到该节点，将该节点值与后驱节点值替换，删除后驱节点。
        //if(i == index) {

            //ListNode* afternode = p -> next;
            //p -> next = afternode -> next;
            //p -> val = afternode -> val;
            //free(afternode);

        //}
        
        p = p -> next;
        i++;
    }
}

int main() {
    int index,value;
    //ListNode* head = List_Head_insert(); //倒序插入不推荐
    //Print_LinkNode(head);

    ListNode* head = List_Tail_insert();//正序插入
    //Print_LinkNode(head);

    //cout << "请输入要查询的节点序号" <<endl;
    //cin >> index;
    //ListNode* res = Selectbyindex(index,head);
    //cout << res -> val;

    //cout << "请输入要查询的节点的值" <<endl;
    //cin >> value;
    //ListNode* res = Selectbyvalue(value,head);
    //cout << res -> val;

    //cout << "请输入要插入的节点序号" <<endl;
    //cin >> index;
    //ListNode* node = new ListNode(4);
    //Insertbyindex(index,head,node);
    //Print_LinkNode(head);

    cout << "请输入要删除的节点序号" <<endl;
    cin >> index;
    ListNode* node = new ListNode(4);
    Deletebyindex(index,head);
    Print_LinkNode(head);
}
背帆
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用C++实现单链表的基本操作
weixin_43165699的博客
07-24 1207
利用C++的模板类，实现了一些对于单链表的一些基本操作，包括插入、删除、查找等基本操作。实现的内容可能相对单薄，但我觉得能够帮助帮助大家对单链表有一个比较好的理解。
C++实现单链表基本操作
diviner_s的博客
01-18 5586
C++实现单链表基本操作 本博客按照上篇博客线性表单链表的基本操作而写出的完整代码，详情请看单链表基础概念 #include<iostream> using namespace std; //函数结果状态代码 #define OK 1 #define ERROR 0 typedef int Status; // Status 相当于 int typedef ...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
使用C++实现单链表的基本操作： 1、创建单链表 2、遍历单链表 3、单链表插入 4、删除单链表 5、判断是否为空 6、单链表的长度 7、单链表查找 8、退出
【C++】单链表——单链表的基本操作
元清的博客
11-30 1814
由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。优点：支持动态内存分配创建一个类。
c++实现单链表基本操作
11-24
实现带头结点单链表的基本操作如逆序建立链表、插入、删除等操作。
单链表的基本操作C++
alanmian的博客
11-05 7789
在这里插入代码片@TOC 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式
数据结构--单链表的基本操作 (C/C++)
weixin_51775646的博客
11-09 4531
实现单链表的创建、插入、删除、查找、取值五种操作 typedef int Status; typedef int ElemType; 解释1.： 定义不同的数据类型名称是为了程序的可读性. 而且一旦你需要将类型变换比如使用double型的了,只要写: typedef double elemtype; 一下子就全改了,如果没有定义的话就要一个个的把int改成double 解释2： typedef int status;是个自定义类型的语句 typedef用来定义类型的别名 status i;.
单链表的基本操作(C++链表实现)
qq_35814058的博客
04-10 3345
[问题描述] 实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。 [基本要求] （1）依次从键盘读入数据，建立带头结点的单链表； (2）输出单链表中的数据元素 （3）求单链表的长度； （4）根据指定条件能够取元素和修改元素； （5）实现在指定位置插入和删除元素的功能 1、初始化链表输入0停止输入： void init(LinkList &L) { LinkList p = new LNode; L = new LNode; L-&gt..
C++实现单链表的16种基本操作
weixin_47373497的博客
10-29 2522
C++实现单链表的16种基本操作 链表初始化，头插法创建链表，尾插法创建链表，取值，查找（第i个节点的数据域或者数据域为某个特定值的节点），有顺序的合并两个链表，无顺序的合并两个链表，插入，删除，逆置链表，求链表的节点个数，删除数据域重复的节点，输出链表，判空，置空链表。 以下是我写的头文件的代码 #ifndef DANLIANBIAO_H #define DANLIANBIAO_H #endif #include<iostream> #include<stdio.h> #inclu
c++单链表基本操作的实现
11-10
1、单链表基本操作的实现 [问题描述]要在带头结点的单链表h中第i个数据元素之前插入一个数据元素x ，首先需要在单链表中寻找到第i-1个结点并用指针p指示，然后申请一个由指针s 指示的结点空间，并置x为其数据域值，最后修改第i-1个结点，并使x结点的指针指向第i个结点，要在带头结点的单链表h中删除第i个结点，首先要计数寻找到第i个结点并使指针p指向其前驱第i-1个结点，然后删除第i个结点并释放被删除结点空间。 [基本要求]用链式存储结构实现存储
C++单链表的基本操作
06-20
c++单链表的基本操作
基于c++的单链表的基本实现以及单链表环的相关操作
最新发布
03-25
本主题将深入探讨如何在C++中实现单链表，并涵盖与环状链表相关的操作。 首先，让我们创建一个表示链表节点的结构体或类。在C++中，通常使用类来封装数据和操作，因此我们将创建一个名为`Node`的类： ```cpp class...
单链表的基本操作——c++（有详细注解）
m0_67228478的博客
03-17 3121
呕心沥血 千辛万苦 凌晨一点仍在调试 上辈子连环杀人，这辈子软件工程 无语住了 #include<iostream> typedef struct LNode{ int date; struct LNode *next; }LNode,*LinkList;//创造一个链表 bool InitList(LinkList &L); void CreateList(LinkList &L,int n); void PrintList(LinkList L); vo
链表的基本操作C++实现
hiahia28的博客
02-07 354
头文件ListNode.h struct ListNode{ int m_nValue; ListNode* m_pNext; }; // 用于声明导入导出函数 // __declspec(dllexport) 声明一个导出函数，一般用于dll中 // __declspec(dllimport) 声明一个导入函数，一般用于使用某个dll的exe中 __declspec(dlle...
c++ 单链表的基本操作
duoerbasilu
07-16 113
#include &lt;iostream&gt; using namespace std; struct Node { int data; Node* next; }; // only for the 1st Node void initNode(struct Node *head,int n){ head-&gt;data = n; head-&gt;next = NULL; }...
C++ 双链表基本操作
qq_40423330的博客
05-18 275
双链表基本操作
C++ 单链表基本操作
nichengwuxiao的博客
12-21 2018
一：目的 用C++实现单链表的基本操作； 一：实现 1. 首先定义单链表的结构和类，书写在LinkList.h中 # include # include using namespace std; //定义节点的value struct Info { string name; //姓名 int id; //学号 Info(string info_name, i
C++单链表基本操作
热门推荐
星痕の博客
07-02 1万+
#include &lt;iostream&gt; using namespace std; struct NODE { int data; NODE * next; }; class List { NODE * head; public: //若构造函数里为head = NULL;则表示不带头结点的链表，只有头指针 List() { head = new NODE; head-&gt...
C++实现单链表构造及常用操作
这些函数涵盖了单链表基本操作的大部分需求，使得在C++中使用链表变得更加方便。 这个C++实现的单链表提供了丰富的功能，能够帮助开发者高效地处理动态数据集合。通过对链表节点的定义和链表类的设计，我们可以轻松...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值