单链表

最新推荐文章于 2024-09-09 23:42:18 发布
最新推荐文章于 2024-09-09 23:42:18 发布
阅读量246 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 单链表 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiaozuo666/article/details/78858705
本文详细介绍了单链表的基本概念及其实现方法，包括初始化、插入、删除等核心功能，并通过示例代码展示了如何进行尾插、尾删、头插、头删等操作。

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

链表

链表：一种链式存储的线性表，用一组地址任一的存储单元存放线性表的数据元素，称存储单元为一各节点

单链表

1 . 结构

typedef int DataType;

typedef struct SListNode
{
    DataType _data;           // 当前节点中所保存的元素
    struct SListNode* _pNext; // 指向下一个结点的指针 
}Node, *PNode;

2 . 功能函数

包含链表的建立，初始化，头删，尾删，头插，尾插，任意位置的插入和删除，链表的输出，链表的判空等

// 初始化单链表 
void SListInit(PNode* ppHead);

// 尾插 
void SListPushBack(PNode* ppHead, DataType data);

// 尾删 
void SListPopBack(PNode* ppHead);

// 头插 
void SListPushFront(PNode* ppHead, DataType data);

// 头删 
void SListPopFront(PNode* ppHead);

// 在链表中查找元素data，返回该结点在链表中的位置 
PNode Find(PNode pHead, DataType data);
// data插入在pos之前 
void SListInsert(PNode* ppHead, PNode pos, DataType data);

// 删除链表中pos位置的结点 
void SListErase(PNode* ppHead, PNode pos);

// 获取链表中结点的个数 
size_t Size(PNode pHead);

// 判断链表是否为空，若为空，返回true，否则返回false 
size_t Empty(PNode pHead);

// 销毁单链表 
void SListDestroy(PNode* pHead);

// 创建结点 
PNode BuySListNode(DataType data);

// 打印单链表 
void SListPrint(PNode pHead);

各部分功能的实现

  • 初始化单链表 
void SListInit(PNode* ppHead)
{
    *ppHead = NULL;
}
  • 尾插 
// 尾插 
void SListPushBack(PNode* ppHead, DataType data)
{
    assert(ppHead);
    PNode newP = BuySListNode(data);
    PNode P = *ppHead;
    if (*ppHead == NULL)
    {
        *ppHead = newP;
    }
    else 
    {
        while (P->_pNext != NULL)
        {
            P = P->_pNext;
        }
        P->_pNext = newP;
    }
}
  • 尾删 
// 尾删 
void SListPopBack(PNode* ppHead)
{
    assert(ppHead);
    PNode Pre = NULL;
    PNode Del = NULL;
    if (*ppHead && (*ppHead) -> _pNext == NULL )
    {
        free((*ppHead));
        *ppHead = NULL;
    }
    else if(*ppHead)
    {
        Del = *ppHead;
        while (Del->_pNext != NULL)
        {
            Pre = Del;
            Del = Del->_pNext;
        }
        Pre->_pNext = NULL;
        free(Del);
    }
}
  • 头插 
// 头插 
void SListPushFront(PNode* ppHead, DataType data)
{
    assert(ppHead);
    PNode newP = BuySListNode(data);
    newP->_pNext = *ppHead;
    *ppHead = newP;
}
  • 头删 
// 头删 
void SListPopFront(PNode* ppHead)
{
    assert(ppHead);

    PNode Del = NULL;
    if((*ppHead) != NULL)
    {
        Del = *ppHead;
        *ppHead = (*ppHead)->_pNext;
        free(Del);
    }

}
  • 在链表中查找元素data，返回该结点在链表中的位置 
// 在链表中查找元素data，返回该结点在链表中的位置 
PNode Find(PNode pHead, DataType data)
{
    while (pHead != NULL)
    {
        if (pHead->_data == data)
        {
            return pHead;
        }
        pHead = pHead->_pNext;
    }
    return NULL;
}
  • data插入在pos之前 
// data插入在pos之前 
void SListInsert(PNode* ppHead, PNode pos, DataType data)
{
    assert(ppHead);
    assert(pos);

    PNode Pnew = BuySListNode(data);
    PNode per = NULL;

    if (pos == *ppHead)
    {
        Pnew->_pNext = *ppHead;
        *ppHead = Pnew;
    }
    else
    {
        per = *ppHead;
        while (pos && per  && per->_pNext != pos)
        {
            per = per->_pNext;
        }
        if (per->_pNext == pos)
        {
            Pnew->_pNext = pos;
            per->_pNext = Pnew;
        }
    }
}
  • 删除链表中pos位置的结点 
// 删除链表中pos位置的结点 
void SListErase(PNode* ppHead, PNode pos)
{
    assert(ppHead);
    PNode pre = *ppHead;

    if(pos == NULL || *ppHead == NULL)
    {
        return 0;
    }
    else if (pos == *ppHead)
    {
        *ppHead = pos->_pNext;
        free(pos);
    }
    else
    {
        while (pre && pre->_pNext != pos)
        {
            pre = pre->_pNext;
        }
        if (pre)
        {
            pre->_pNext = pos->_pNext;
            free(pos);
        }
    }
}
  • 获取链表中结点的个数 
// 获取链表中结点的个数 
size_t Size(PNode pHead)
{
    size_t num = 0;
    while (NULL != pHead)
    {
        num++;
        pHead = pHead->_pNext;
    }
    return num;
}
  • 判断链表是否为空，若为空，返回true，否则返回false 
// 判断链表是否为空，若为空，返回true，否则返回false 
size_t Empty(PNode pHead)
{
    if (NULL == pHead)
    {
        return 1;
    }
    else return 0;
}
  • 销毁单链表 
// 销毁单链表 
void SListDestroy(PNode* pHead)
{
    assert(pHead);

    if ((*pHead) != NULL)
    {
        SListDestroy(&((*pHead)->_pNext));
    }
    if((*pHead) != NULL)
    {
        free((*pHead));
    }
}
  • 创建结点 
// 创建结点 
PNode BuySListNode(DataType data)
{
    PNode newP =  NULL;
    newP = (PNode)malloc(sizeof(Node));
    if (newP == NULL)
    {
        printf("error\n");
        return 0;
    }
    newP->_data = data;
    newP->_pNext = NULL;
    return newP;
}
  • 打印单链表 
// 打印单链表 
void SListPrint(PNode pHead)
{
    while (pHead != NULL)
    {
        printf("%d ", pHead->_data);
        pHead=pHead->_pNext;
    } 
    printf("\n");
}

代码

代码实现（Visual studio 2017）

  • test.c 文件

//主函数
int main()
{
    //尾插测试
    PushBack_test();
    //尾删测试
    PopBack_test();
    //头插测试
    PushFront_test();
    //头删测试
    PophFront_test();
    //data插入在pos之前测试
    SListInsert_test();
    // 删除链表中pos位置的结点 
    SListErase_test();
    // 链表中结点个数测试
    Size_test();
    // 销毁单链表测试 
    SListDestroy_test();

    system("pause");
    return 0;
}
  • SListNode.h 文件
#pragma once

#ifndef _SLISTNODE_H_
#define _SLISTNODE_H_



typedef int DataType;

typedef struct SListNode
{
    DataType _data;
    struct SListNode* _pNext; // 指向下一个结点的指针 
}Node, *PNode;


// 初始化单链表 
void SListInit(PNode* ppHead);

// 尾插 
void SListPushBack(PNode* ppHead, DataType data);

// 尾删 
void SListPopBack(PNode* ppHead);

// 头插 
void SListPushFront(PNode* ppHead, DataType data);

// 头删 
void SListPopFront(PNode* ppHead);

// 在链表中查找元素data，返回该结点在链表中的位置 
PNode Find(PNode pHead, DataType data);
// data插入在pos之前 
void SListInsert(PNode* ppHead, PNode pos, DataType data);

// 删除链表中pos位置的结点 
void SListErase(PNode* ppHead, PNode pos);

// 获取链表中结点的个数 
size_t Size(PNode pHead);

// 判断链表是否为空，若为空，返回true，否则返回false 
size_t Empty(PNode pHead);

// 销毁单链表 
void SListDestroy(PNode* pHead);

// 创建结点 
PNode BuySListNode(DataType data);

// 打印单链表 
void SListPrint(PNode pHead);

#endif
  • SListNode.c 文件
#include <stdio.h>
#include <windows.h>
#include <assert.h>
#include <stdlib.h>
#include "SListNode.h"

// 初始化单链表 
void SListInit(PNode* ppHead)
{
    *ppHead = NULL;
}

// 尾插 
void SListPushBack(PNode* ppHead, DataType data)
{
    assert(ppHead);
    PNode newP = BuySListNode(data);
    PNode P = *ppHead;
    if (*ppHead == NULL)
    {
        *ppHead = newP;
    }
    else 
    {
        while (P->_pNext != NULL)
        {
            P = P->_pNext;
        }
        P->_pNext = newP;
    }
}

// 尾删 
void SListPopBack(PNode* ppHead)
{
    assert(ppHead);
    PNode Pre = NULL;
    PNode Del = NULL;
    if (*ppHead && (*ppHead) -> _pNext == NULL )
    {
        free((*ppHead));
        *ppHead = NULL;
    }
    else if(*ppHead)
    {
        Del = *ppHead;
        while (Del->_pNext != NULL)
        {
            Pre = Del;
            Del = Del->_pNext;
        }
        Pre->_pNext = NULL;
        free(Del);
    }
}

// 头插 
void SListPushFront(PNode* ppHead, DataType data)
{
    assert(ppHead);
    PNode newP = BuySListNode(data);
    newP->_pNext = *ppHead;
    *ppHead = newP;
}

// 头删 
void SListPopFront(PNode* ppHead)
{
    assert(ppHead);

    PNode Del = NULL;
    if((*ppHead) != NULL)
    {
        Del = *ppHead;
        *ppHead = (*ppHead)->_pNext;
        free(Del);
    }

}

// 在链表中查找元素data，返回该结点在链表中的位置 
PNode Find(PNode pHead, DataType data)
{
    while (pHead != NULL)
    {
        if (pHead->_data == data)
        {
            return pHead;
        }
        pHead = pHead->_pNext;
    }
    return NULL;
}

// data插入在pos之前 
void SListInsert(PNode* ppHead, PNode pos, DataType data)
{
    assert(ppHead);
    assert(pos);

    PNode Pnew = BuySListNode(data);
    PNode per = NULL;

    if (pos == *ppHead)
    {
        Pnew->_pNext = *ppHead;
        *ppHead = Pnew;
    }
    else
    {
        per = *ppHead;
        while (pos && per  && per->_pNext != pos)
        {
            per = per->_pNext;
        }
        if (per->_pNext == pos)
        {
            Pnew->_pNext = pos;
            per->_pNext = Pnew;
        }
    }
}

// 删除链表中pos位置的结点 
void SListErase(PNode* ppHead, PNode pos)
{
    assert(ppHead);
    PNode pre = *ppHead;

    if(pos == NULL || *ppHead == NULL)
    {
        return 0;
    }
    else if (pos == *ppHead)
    {
        *ppHead = pos->_pNext;
        free(pos);
    }
    else
    {
        while (pre && pre->_pNext != pos)
        {
            pre = pre->_pNext;
        }
        if (pre)
        {
            pre->_pNext = pos->_pNext;
            free(pos);
        }
    }
}


// 获取链表中结点的个数 
size_t Size(PNode pHead)
{
    size_t num = 0;
    while (NULL != pHead)
    {
        num++;
        pHead = pHead->_pNext;
    }
    return num;
}

// 判断链表是否为空，若为空，返回true，否则返回false 
size_t Empty(PNode pHead)
{
    if (NULL == pHead)
    {
        return 1;
    }
    else return 0;
}

// 销毁单链表 
void SListDestroy(PNode* pHead)
{
    assert(pHead);

    if ((*pHead) != NULL)
    {
        SListDestroy(&((*pHead)->_pNext));
    }
    if((*pHead) != NULL)
    {
        free((*pHead));
    }
}

// 创建结点 
PNode BuySListNode(DataType data)
{
    PNode newP =  NULL;
    newP = (PNode)malloc(sizeof(Node));
    if (newP == NULL)
    {
        printf("error\n");
        return 0;
    }
    newP->_data = data;
    newP->_pNext = NULL;
    return newP;
}

// 打印单链表 
void SListPrint(PNode pHead)
{
    while (pHead != NULL)
    {
        printf("%d ", pHead->_data);
        pHead=pHead->_pNext;
    } 
    printf("\n");
}

//尾插测试
void PushBack_test()
{
    PNode pHead;
    SListInit(&pHead);

    printf("尾插测试\n");
    SListPushBack(&pHead, 0);
    SListPrint(pHead);
    SListPushBack(&pHead, 1);
    SListPrint(pHead);
    SListPushBack(&pHead, 2);
    SListPrint(pHead);
    SListPushBack(&pHead, 3);
    SListPrint(pHead);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);
}
//尾删测试
void PopBack_test()
{
    PNode pHead;
    SListInit(&pHead);

    printf("尾删测试\n");
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);

    SListPopBack(&pHead);
    SListPrint(pHead);
    SListPopBack(&pHead);
    SListPrint(pHead);
    SListPopBack(&pHead);
    SListPrint(pHead);
    SListPopBack(&pHead);
    SListPrint(pHead);
    SListPopBack(&pHead);
    SListPrint(pHead);
    SListPopBack(&pHead);
    SListPrint(pHead);
    SListPopBack(&pHead);
    SListPrint(pHead);
}

//头插测试
void PushFront_test()
{
    PNode pHead;
    SListInit(&pHead);
    printf("头插测试\n");

    SListPushFront(&pHead, 1);
    SListPrint(pHead);
    SListPushFront(&pHead, 2);
    SListPrint(pHead);
    SListPushFront(&pHead, 3);
    SListPrint(pHead);
    SListPushFront(&pHead, 4);
    SListPrint(pHead);
    SListPushFront(&pHead, 5);
    SListPrint(pHead);
    SListPushFront(&pHead, 6);
    SListPrint(pHead);
}

//头删测试
void PophFront_test()
{
    PNode pHead;
    SListInit(&pHead);
    printf("头删测试\n");

    SListPushFront(&pHead, 1);
    SListPushFront(&pHead, 2);
    SListPushFront(&pHead, 3);
    SListPushFront(&pHead, 4);
    SListPushFront(&pHead, 5);
    SListPushFront(&pHead, 6);
    SListPrint(pHead);

    SListPopFront(&pHead);
    SListPrint(pHead);
    SListPopFront(&pHead);
    SListPrint(pHead);
    SListPopFront(&pHead);
    SListPrint(pHead);
    SListPopFront(&pHead);
    SListPrint(pHead);
    SListPopFront(&pHead);
    SListPrint(pHead);
    SListPopFront(&pHead);
    SListPrint(pHead);
    SListPopFront(&pHead);
    SListPrint(pHead);
    SListPopFront(&pHead);
    SListPrint(pHead);
}

//data插入在pos之前测试
void SListInsert_test()
{
    PNode pHead;
    SListInit(&pHead);
    printf("插入测试\n");

    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);

    SListInsert(&pHead, Find(pHead,0), 9);
    SListPrint(pHead);
    SListInsert(&pHead, Find(pHead, 2), 9);
    SListPrint(pHead);
    SListInsert(&pHead, Find(pHead, 4), 9);
    SListPrint(pHead);
}

// 删除链表中pos位置的结点 
void SListErase_test()
{
    PNode pHead;
    SListInit(&pHead);
    printf("删除测试\n");

    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);

    SListErase(&pHead, Find(pHead, 0));
    SListPrint(pHead);
    SListErase(&pHead, Find(pHead, 2));
    SListPrint(pHead);
    SListErase(&pHead, Find(pHead, 4));
    SListPrint(pHead);
    SListErase(&pHead, Find(pHead, 1));
    SListPrint(pHead);
    SListErase(&pHead, Find(pHead, 3));
    SListPrint(pHead);
}

// 链表中结点个数测试
void Size_test()
{
    int num = 0;
    PNode pHead;
    SListInit(&pHead);
    printf("个数测试\n");


    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);

    num = Size(pHead);
    printf("节点个数为：%d \n", num);
}

// 销毁单链表测试 
void SListDestroy_test()
{

    PNode pHead;
    SListInit(&pHead);
    printf("销毁测试\n");


    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);

    SListDestroy(&pHead);
}
单链表插入
Python、C++、HTML、Java
09-23 1065
【问题描述】 设有头结点单链表，实现单链表插入算法。 【输入形式】 第一行输入一个N（N大于等于1，小于1000）； 第二行输入N个整数，以空格作为分隔，创建长度为N的单链表； 第三行输入pos和e，以空格分隔，分别表示插入位置和插入元素的值。 【输出形式】 若插入成功，输出插入元素后的单链表；若插入不成功，输出error。
C语言—单链表
最新发布
2302_81120572的博客
10-06 3923
C语言—单链表
数据结构-单链表基本操作-C语言代码
热门推荐
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
建立单链表
Dream_begin_的博客
01-11 5756
链表是动态地进行存储分配的一种结构，链表中的数据在内存中不必连续存放，数据之间通过指针链接起来，相比于数组结构，链表的插入和删除操作比较方便。单链表的建立链表：通过自引用结构的指针域，将各结点相互连接。关于链表的基本概念： (1)链表的第一个结点称头指针或头结点，它指向链表在内存中的首地址， (2)其后的结点是通过结点中的链节指针成员访问的。 (3)链表的最后一个结点称为尾节点。尾节点的指针域通常被设置成NULL。 (4)链表中的每一个结点是在需要的时候建立的。 (5)各结点在内存中的存储地址不一
数据结构————单链表
m0_66847953的博客
09-09 7501
单链表（Singly Linked List）是一种基本的数据结构，它由一系列节点组成，每个节点包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则存储指向链表中下一个节点的地址。在单链表中，除了最后一个节点外，每个节点的指针域都指向下一个节点，最后一个节点的指针域通常设置为NULL，以标识链表的结束。单链表的特点是其存储不需要连续的内存空间，节点可以分散在内存中的任意位置，通过指针连接形成线性结构。头插法指的是在单链表的头部插入节点。新节点的指针将指向当前的头节点，然后更新头指针以指向新节点。
C语言单链表
knighthood2001
05-06 2272
int data;} Node;这里我们使用typedef将struct Node命名为Node。当然很多书以及代码中会使用到如下的int data;这里它还定义了一个指向这个结点的指针，当然对于初学者（笔者也是初学者）来说。使用*LinkList后，不太好理解，这里笔者就使用上述Node的版本。
单链表简单实现
南猿北者博客
10-31 2532
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；
C++单链表逆序
m0_51380378的博客
07-12 1109
牛客网真题：单链表的逆序 C++的单链表逆序： 创建3个指针，分别指向当前头节点位置，空空。 先将一个指针指向头节点的下一个节点，下一个节点为当前节点的下一个节点，当前节点的下一个节点为前一个节点，前一个结点为当前节点，当前节点为下一个节点。 struct ListNode* ReverseList(struct ListNode* pHead ) { // write code here struct ListNode *pre = NULL; struct Li
关于单链表
优快云_YJX的博客
04-07 193
基础知识：什么是单链表，链式存储结构详解 单链表 基础操作：单链表的基本操作（C语言版） 最后附加一篇大佬的文章 【C语言】链表及单链表基本操作
单链表-实验报告.doc
03-10
在计算机科学与技术领域，单链表是一种重要的基础数据结构，它由一系列节点组成，每个节点包含数据域和指针域，其中指针域指向下一个节点。单链表的节点之间通过指针连接，形成一条单向的线性结构。单链表的特点是...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
本文将详细阐述如何使用C++来实现单链表的基本操作，包括创建、遍历、插入、删除、判断空、计算长度以及查找节点。 首先，我们从创建单链表开始。单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
Sort_排序代码集合汇总
小Z的博客
03-28 985
头文件 Sort_all.h #pragma once #ifndef _SORT_ALL_H_ #define _SORT_ALL_H_ // 插入排序 // 直接插入排序 void InsertSort(int* array, int size); // 插入排序使用二分进行优化 void InsertSort_OP(int* array, int size); // ...
哈希之闭散列-线性算法和二次探查法
小Z的博客
03-03 586
头文件 Hash.h #pragma once #ifndef HASH_H_ #define HASH_H_ #define size_t unsigned long typedef enum { EM, EXIST, DEL } State; typedef int Value; //typedef char* Value; typedef struct _...
删除单链表的非尾结点
小Z的博客
12-28 536
删除单链表的非尾节点（不能遍历链表） 思路：由于单链的的特性，在不遍历链表的情况下，很难找到要删除节点(Cur)的前一个节点(Pre)，在删除该节点(Cur)后，没有办法将该节点之前的节点和之后的节点连接起来，因此我们采用替换删除的方法，就是将该节点(Cur)的下一个节点(Next)得到，然后将下一个节点(Next)的值赋给该节点(Cur)，再将下一个节点(Next)删除，该节点(Cur)链接上
从尾到头打印单链表
小Z的博客
12-22 489
倒序打印数据：我们一般采用先遍历一遍数据，找到最后一个数据，然后从尾到头打印的方式，但是由于单链表的不可逆性，因此倒序打印单链表不能采用普通的方式打印。首先我们要解决一个问题：怎么在打印完一个数据后，可以找到前一个数据。解决这个问题后我们就可以进行倒序打印了。 明确问题后我们就开始解决问题，这里我将提供三种方法。 1 . 数组法 很简单的思路，就是构建一个DataType类型的数组，将单链表的所
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值