数据结构：线性表之链表的总结

最新推荐文章于 2022-05-06 23:15:42 发布
最新推荐文章于 2022-05-06 23:15:42 发布
阅读量2.3k 收藏
点赞数 2
分类专栏： 数据结构学习总结 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44025784/article/details/105865865
版权

1 单链表

1.1 初始化

1.1.1 不带头结点的单链表

typedef struct LNode{    //定义单链表结点类型
    ElemType data;       
    struct LNode *next;  //指针指向下一个结点
}LNode, *LinkList;

//初始化一个空的单链表（不带头结点）
bool InitList(LinkList &L) {
    L = NULL;            //空表，暂时没有任何结点
    return true;
}

//判断单链表是否为空
bool Empty (LinkList L) {
    if (L == NULL)
        return true;
    else
        return false;
}

void main(){
    LinkList L;          //声明一个指向单链表的指针
    //初始化一个空表
    InitList(L):
    //……
}

注：

  1. 此操作只是声明一个指向单链表的指针，然后使该指针指向空，这个单链表里面还没有结点
  2. 检查此时单链表是否为空，只需要看L这个指针是否为空即可
  3. L即为头指针
  4. 当单链表存放数据时，头指针指向第一个实际存放数据的结点

1.1.2 带头结点的单链表

typedef struct LNode{    //定义单链表结点类型
    ElemType data;       
    struct LNode *next;  //指针指向下一个结点
}LNode, *LinkList;

//初始化一个单链表(带头结点)
bool InitList(LinkList &L) {
    L = (LNode*)malloc(sizeof(LNode)); //分配一个头结点，头指针L指向头结点
    if (L == NULL)
        return false;       //头指针后面应该有头结点，如果没有，说明空间不足，头结点分配失败
    L->next = NULL;         //头结点之后是空的，说明还没有其他结点
    return true;                
}

//判断单链表是否为空
bool Empty (LinkList L) {
    if (L->next == NULL)    头结点之后是空的，说明还没有其他结点
        return true;
    else
        return false;
}

void main(){
    LinkList L;          //声明一个指向单链表的指针
    //初始化一个空表
    InitList(L):
    //……
}

注：

  1. 头指针L指向头结点
  2. 头结点中还没有数据
  3. 判断此时单链表是否为空，只需判断头结点之后是否为空
  4. 当单链表存放数据时，头指针指向头结点，第一个带数据的结点在头结点之后

1.1.3 LNode 、LNode * 、LinkList的联系与区别

1、LNode 是struct LNode这个结构体的别名，而这个结构体是用来创建单链表的结点。
2、LinkList 是指向单链表结点的指针
3、LNode* 等价于LinkList
4、当强调这是结点时使用LNode* ；强调这是单链表时使用LinkList

1.2 按位序插入

1.2.1 带头结点的单链表——O(n)

思想：

  1. 判断插入的位序 i 是否合法，若此单链表结点的个数为n，则可插入的位序的范围为（1，n+1）
  2. 循环找到第 i -1 个结点
  3. 为新插入的结点分配空间，并将数据赋给新结点
  4. 将新结点插入
typedef struct LNode {
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//按位序插入——带头结点
//在第i个位置插入元素e
bool ListInsert (LinkList &L, int i, ElemType e){
    if( i<1 ){                  //【1】判断插入的位序是否>=1
        return false;
    }
    LNode *p;
    int j=0;
    p = L;                      //L为头结点，头结点是第0个结点，第一个结点是存放数据的结点
    while ( p!=NULL && j<i-1){  //【2】循环找到第i-1个结点   
        p = p->next;
        j++;
    }
    if (p == NULL){             //【1】判断插入的位序是否<=n
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode)); //【3】为新结点分配空间，并定义指针s指向新结点
    s->data = e;                //【3】将数据赋值给新结点
    s->next = p->next;          //【4】插入新结点
    p->next = s;
    return true;
}

注：

  1. 判断插入的位序是否符合（1，n+1）时，由于单链表的结点个数n是未知的，所以两个条件分别进行判断
  2. 插入的两行代码的顺序不可变换

1.2.2 不带头结点的单链表——O(n)

思想：

  1. 判断插入的位序 i 是否 >= 1
  2. 由于不带头结点的单链表的头指针是指向第一个结点的，因此，若插入的结点为第一个结点时，插入操作结束后，还需将头指针重新指向新插入的结点。因此，对于 i = 1 时，单独操作。
  3. i > 1的操作与带头结点的步骤相同
typedef struct LNode {
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//2、按位序插入——不带头结点
//在第i个位置插入元素e
bool ListInsert (LinkList &L, int i, ElemType e){
    if( i<1 ){                  //【1】判断插入的位序是否>=1
        return false;
    }
    if ( i == 1 ){
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;                  //头指针指向新结点
        return true;
    }
    LNode *p;
    int j=1;                    //注意：j的值和带头结点的单链表的值的操作中不同
    p = L;                      //p指向第一个结点
    
    while ( p!=NULL && j<i-1){  //【2】循环找到第i-1个结点   
        p = p->next;
        j++;
    }
    if (p == NULL){             //【1】判断插入的位序是否<=n
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode)); //【3】为新结点分配空间，并定义指针s指向新结点
    s->data = e;                //【3】将数据赋值给新结点
    s->next = p->next;          //【4】插入新结点
    p->next = s;
    return true;
}

注：

  1. 注意 j 的值在带头结点的单链表和不带头结点的单链表中的区别。
  2. 带头结点的单链表中，有第0个结点，即头结点；不带头结点的单链表中直接从第一个结点开始。 j 代表的就是指针 p 指向的是第几个结点。

1.2.3 指定结点的后插——O(1)

思想：

  1. 判断指定的结点p是否存在
  2. 为新元素e分配空间，并检测是否分配成功
  3. 插入
//指定结点的后插操作
//在p结点之后插入元素e
bool insertNextNode (LNode *p, ElemType e){
    if (p == NULL){             //【1】判断p结点是否存在
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode)); //【2】为新结点分配空间，并定义指针s指向新结点
    if (s == NULL){
        return false;
    }
    s->data = e;                //【3】将数据赋值给新结点
    s->next = p->next;          //【4】插入新结点
    p->next = s;
    return true;
}

注：

  1. 其实按位序插入就是对第i-1个元素进行后插操作，可在循环找到第i-1个元素后，直接调用后插操作函数进行。

1.2.4 指定结点的前插——O(1)

思想：

  1. 将新结点s插在指定结点p的后面
  2. 将s和p的数据对换
//指定结点的前插操作
//在p结点之前插入元素e
bool InsertPriorNode (LNode *p, ElemType e){
    if (p == NULL){             //【1】判断p结点是否存在
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode)); 
    if (s == NULL){
        return false;
    }
    s->next = p->next;          //【3】将新结点s插在p结点之后
    p->next = s;
    s->data = p->data;          //【4】将p结点、s结点的数据对换
    p->data = e;
    return true;
}

注：

  1. 前插有两种思想，一是找到指定结点的前驱结点，再对前驱结点进行后插；二是将新结点插在指定结点之后，再将两个结点的数据对换
  2. 由于单链表想找到指定结点的前驱结点，只能在已知头指针的单链表中循环遍历找到，且时间负责度为O(n)。若头指针不可知，则无法找到。所以使用思想二更好。

1.3 删除

1.3.1 带头结点的按位序删除——O(n)

思想：

  1. 找到第i-1个元素
  2. 判断待删除的第i个元素以及第i-1个元素是否存在
  3. 将第i+1个元素连接到第i-1个元素后
  4. 返回第i个元素的值，并释放其存储空间
//删除第i个元素
bool ListDelete (LinkList &L, int i, ElemType e){
    if( i<1 ){                  
        return false;
    }
    LNode *p;                      //找到第i-1个元素
    int j=0;                    
    p = L;                      
    while ( p!=NULL && j<i-1){  
        p = p->next;
        j++;
    }
    if (p == NULL){                //判断第i-1个元素        
        return false;
    }
    if (p->next == NULL){          //判断第i个元素            
        return false;
    }
    LNode *q = p->next;            //用指针q指向第i个元素
    e = q->data;                   //返回被删除元素的数据
    p->next = q->next;             //第i+1个元素连接到第i-1个元素之后
    free(q);                       //释放第i个元素
    return true;
}

1.3.2 删除指定结点——O(n)

思想：

  1. 将结点p+1和结点p的数据交换
  2. 再将p+2连接到p结点之后
//删除指定结点p
bool DeleteNode (LNode *p){
    if ( p == NULL )
        return false;
    LNode *q = p->next;       // q 指向 p 的后继结点
    p->data = p->next->data;  // p 和 p+1 的数据交换
    p->next = q->next;        // p+2 连接到 p 后面
    free(q);
    return true;
}

注：

  • 若删除的结点p是最后一个结点，只能从头开始检索第p-1个结点——O(n)

1.4 查找

1.4.1 按位查找——O(n)

//按位查找
LNode * GetElem (LinkList L, int i){
    if(i<0)
        return NULL;            
    LNode *p;
    int j=0;                    //j表示p指向的是第几个结点
    p = L;                      //p指向头结点，即第0个结点
    while ( p!=NULL && j<i-1){  
        p = p->next;
        j++;
    }
    return p;                   //若查找的i>n，返回的p也是NULL
}

1.4.2 按值查找——O(n)

//按值查找
//找到数据为e的结点
LNode * LocaleElem( LinkList L, ElemType e ){
    LNode *p = L->next;     //p为头结点之后的第一个结点
    while ( p != NULL && p->data != e)
        p = p->next;
    return p;
}

1.5 求表长——O(n)

//求表长
int Length(LinkList L){
    int len = 0;
    LNode *p = L;
    while (p->next != NULL){
        p = p->next;
        len++;
    } 
    return len;
}

1.6 单链表的建立

1.6.1 尾插法

思想：

  1. 初始化一个空表，这里通过建立头结点来做到
  2. 每次输入的数据都存在结点s中
  3. 每个结点建立完毕后，插到尾指针之后
  4. 尾指针永远指向最后一个新建立的结点s
//尾插法建立单链表
LinkList Lis_TailInsert(LinkList &L){
    int x;                //设ElemType为整形
    L = (LinkList)malloc(sizeof(LNode));     //建立头指针，即初始化空表
    L->next = NULL;
    LNode *s, *r=L;       //r为尾指针
    scanf("%d", &x);
    while( x!= 9999 ){    //输入9999表示结束，也可使用其他数字来代替999
        s = (LNode*)malloc(sizeof(LNode));   //建立新结点
        s->data = x;
        r->next = s;      //在结点r之后插入新结点
        r = s;            //尾指针指向新结点，即尾指针永远指向最后一个结点
        scanf("%d", &x);
    }
    r->next = NULL;       //尾结点指针指空
    return L;
    
}

1.6.2 头插法

思想：

  1. 初始化空链表
  2. 建立新结点
  3. 对头指针做后插操作
//头插法建立单链表
LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));  //初始化空链表，L为头指针
    L->next = NULL;
    scanf("%d", &x);
    while(x != 9999){
        s = (LNode*)malloc(sizeof(LNode)); //建立新结点
        s->data = x;  
        s->next = L->next;                 //对头指针进行后插
        L->next = s;
        scanf("%d", &x);
    }
    return L;
}

注：

  • 头插法的应用——链表的逆置

2 双链表

2.1 结点的定义

//双链表结点的定义
typedef struct DNode{
    ElemType data;
    struct DNode *prior, &next;
}DNode, *DLinklist;

2.2 双链表的初始化（带头结点）

//双链表的初始化（带头结点）
bool InitDLinkList (DLinklist &L){
    L = (DNode *)malloc(sizeof(DNode));  //分配一个头结点
    if (L == NULL)          //内存不足，分配失败
        return false;
    L->prior = NULL;        //头结点的prior永远指向NULL
    L->next = NULL;         //头结点之后暂时还没有结点
    return true;
}

2.3 判空——判断双链表是否为空

思想：

  • 头结点的后继指针指向的是空，即双链表为空
//双链表的判空
bool Empty(DLinklist L){
    if (L->next == NULL)
        return ture;
    else 
        return false;
}

2.4 双链表的插入

思想：

  1. 将结点s插入结点p和结点p+1之间
  2. s的后继指针指向p+1
  3. p+1的前驱指针指向s
  4. s的前驱指向p
  5. p的后继指向s
  6. 即先完成s和p+1的联系，再完成p和s的联系
//双链表的插入
//在p结点之后插入s结点
bool InsertNextDNode(DNode *p, DNode *s){
    if( p == NULL || s == NULL)
        return false;
    s->next = p->next;       // 2
    if( p->next != NULL)
        p->next->prior = s;  // 3
    s->prior = p;            // 4
    p->next = s;             // 5
}

注：

  1. 结点p和s需要判断是否合法，即是否不为空
  2. 当结点p为最后一个结点时，步骤3（p+1的前驱指针指向s）就需要考虑是否需要

2.5 双链表的删除

思想：

  1. 结点顺序分别为p、q、p+1，待删除的结点是q
  2. p的后继指向p+1
  3. p+1的前驱指向p
//双链表的删除
//删除结点p的后继结点
bool DeleteNextDNode(DNode *p){
    if( p == NULL )         //判断结点p是否合法
        return false;
    DNode *q = p->next;     //q为结点p的后继结点，即待删除的结点
    if( q == NULL )         //判断结点q是否合法
        return false;
    p->next = q->next;      //p的后继指向p+1
    if( q->next != NULL )   //考虑p+1是否为空
        q->next->prior = p; //若p+1不为空，再将p+1的前驱指向p
    free(q);                //释放删除结点的空间
    return true;
}

注：

  • 考虑p+1是否为空指针，再决定是否需要将p+1的前驱指向p

2.6 双链表的销毁

思想：

  • 循环删除头结点的后继结点
//双链表的销毁

void DestoryList(DLinklist &L){
    while ( L->next != NULL )
        DeleteNextDNode(L);   //循环删除头结点后的结点
    free(L);      //释放头结点
    L=NULL;       //头指针指向NULL
}

注：

  1. 头结点也需释放
  2. 头指针需指向空

3 循环链表

3.1 循环单链表

3.1.1 结点的定义

//循环单链表结点的定义
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

3.1.2 初始化

//循环单链表的初始化
bool InitList( LinkList &L) {
    L = (LNode *)malloc(sizeof(LNode));  //分配头结点
    if( L == NULL )      //内存不足，分配失败
        return false;
    L->next = L;         //自己指向自己
    return true;
}

3.1.3 判空

//循环单链表的判空
bool Empty( LinkList L ) {
    if ( L->next == L )
        return true;
    else
        return false;
}

3.1.4 表尾结点的判断

//判断循环单链表的表尾结点
bool isTail ( LinkList L, LNode *p ) {
    if ( p->next == L )  //结点p的后继是否指向头结点
        return true;
    else
        return false;
}

3.2 循环双链表

3.2.1 结点的定义

//循环双链表结点的定义
typedef struct DNode{
    ElemType data;
    struct DNode *prior, *next;
}DNode, *DLinklist;

3.2.2 初始化

//循环双链表的初始化
bool InitDLinkList( DLinklist &L) {
    L = (DNode *)malloc(sizeof(DNode));
    if ( L == NULL )
        return false;
    L->prior = L;     //头结点的前驱指向头结点
    L->next = L;      //头结点的后继指向头结点
    return true;
}

3.2.3 判空

//循环双链表的判空
bool Empty(DLinklist L) {
    if( L->next == L )
        return true;
    else
        return false;
}

3.2.4 表尾结点的判断

//判断循环双链表的表尾结点
bool isTail( DLinklist L, DNode *p) {
    if ( p->next == L ) //判断结点p的后继是不是指向头结点
        return true;
    else
        return false;
}
叶耶ce
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的总结
hzcx777的博客
10-28 1071
一．线性表（ Linear List ）的定义：线性表是零个或多个具有相同类型的数据元素的有限序列。数据元素的个数定义为线性表的 长度 。长度等于零时称为空表，一个非空表通常记为 L ＝ ( a 1 ， a 2 ，……， a n ) 其中， a i （ 1 ≤ i ≤ n ）称为数据元素，下标 i 表示该元素在线性表中的位置或序号， 称元素 a i 位于表的第 i 个位置，或称 a i 是表中的第...
数据结构与算法学习总结-线性表的链式存储与实现
空谷回响的编码史
02-21 857
　　实现线性表的另一种方法时链式存储，即用指针将存储线性表中数据元素的那些单元依次串联在一起。这种方法避免了再数组中用练习的单元存储元素的缺点，因而在执行插入或删除运算时，不再需要移动元素来腾出空间或填补空缺。相应的，我们需要再每个单元中设置指针来表示表中元素之间的逻辑关系，因而增加了额外的存储空间的开销。 1.单链表 　　链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至...
线性表之顺序存储结构与链式存储结构 及 应用
踩踩踩从踩的博客
06-22 3803
前言 我们常用的线性基本是顺序存储结构和链式存储结构表示，是最基本、最简单、也是最常用的一种数据结构；一个线性表是由n个相同特性的数据的有限序列；比如java中的数组 ，链表；所以研究这两种结构是非常必要的。
实验二：线性表总结 （单链表和顺序表的区别）
beibeiyuan123的专栏
10-19 1383
单链表就是一个节点链一个节点的那种而顺序表，通常采用动态数组的形式。 区别就是内存上的区别。 连续与不连续。 操作上的区别，单链表在增删上面有优势，比顺序表效率高。 顺序表增删还需要移动 顺序表的优势，可以通过下标直接索引到该元素，查询快
数据结构之线性表-链表的基本操作及其应用总结(带有详细注释及说明)
Carson's Blog
05-06 1630
单链表的基本操作 链表基本操作注意的两个点: > 1: 插入删除操作时,一定要找到直接前驱,以防止断链! > 2: 单链表操作,往往伴随 while§ 或 while(p!=NULL) 创建单链表的两种方式 头插法 头插法返回头指针 /* 头插法(每次新结点都插入在头结点后,第一个数据结点之前),形成逆序的单链表 */ //注意: 定义指针变量,为了安全起见和习惯,一般需要初始化为NULL #include <stdio.h> #include <stdlib.h&g
数据结构：线性表、链表、队列、栈、串
11-24
包含数据结构中线性表、链表、队列、栈、串等几种结构的常见操作，以及顺序和链式存储过程
数据结构：线性表(链接存储).ppt
06-19
数据结构：线性表（链接存储） 一、线性表的链接存储 线性表的链接存储是一种存储方式，它可以克服顺序存储的缺点。顺序存储需要一块连续的存储空间，但是当顺序表很大时，系统可能无法分配这么大的一块连续存储...
数据结构教学课件：线性表链表.ppt
09-17
数据结构教学课件：线性表链表.ppt
c/c++数据结构-线性表-链表
04-26
数据结构实验线性表当中的链表结构实现，带有详细注释，小白也能看得懂
C++数据结构实验一：线性表的应用
03-29
3．了解循环链表、双(循环)链表的结构特点和在其上施加的插入、删除等操作。 4. 掌握线性表的逻辑结构特点、顺序存储结构、链式存储结构、顺序表的结构体类型定义、单链表的结构体类型定义、在两种存储结构上的各种...
单链表定义
weixin_50311592的博客
04-21 2162
单链表 定义 特点：每个结点除了存放数据元素外，还要存储指向下一个节点的指针 优点：不要求大片连续空间，改变容量方便 缺点：不可随机存取，要耗费一定空间存放指针 用代码定义一个单链表 struct LNode{//定义单链表结点类型 ElemType data;//每个节点存放一个数据元素，data数据域 struct LNode *next;//指针指向下一个节点，next指针域 }; struct LNode *p=(struct LNode *)malloc(sizeof(struc
typedef struct Lnode{ Elemtype data； struct Lnode *next； } Lnode,*Linklist；
qq_43615815的博客
05-22 9168
*next是指向下一个值的地址 而*Linklist是当前这个值的地址，只是这个值里有数据data，和下一个值的地址 就是说链表中，因为数据是随机储存的，所以地址不是连续的，要想读取下一个数，就要知道下一个数据的地址 不知道有没有看懂，表达能力不是很好 *Linklist相当于一个数组头指针，只是这个数组的元素是结构体 *next则是构成链表的一个基本元素，指向该结点下一个结点的地址 从某种意义上讲，*Linklist是指定了这段空间在内存中的位置（可以申请连续的结点空间），而*next则对结点进行了一
关于单链表结构体定义结点时 LNode *LinkList的理解
ChadWick的博客
12-24 8569
typedef struct LNode{ ElemType data； //数据域 struct LNode *next; //指针域 }LNode, *LinkList 先说结论，这个就可以直接理解为 第一个是便于定义变量的类型为LNode,如果没有使用typedef，定义时就需要写 struct LNode Lnode; 第二个是便于定义指向LNode这个类型的指针 举个栗子： 在表示一个单链表时，只需声明一个头指针L，指向单链表的第一个结点(也就是头结点） Lnode *L //声明一个指
2.1.单链表的定义
qq_45785650的博客
07-25 1523
用代码定义一个单链表 typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; #include<stdio.h> #include<stdlib.h> typedef struct LNode{ //定义单链表的节点类型 ElemType data; //每个节点存放一个数据元素 struct LNode *next; //指针指向下一个节点 }L
typedef介绍
reason的博客
10-14 1177
本文介绍typedef的用法。 1. 概述 typedef为C语言的关键字，作用是为一种数据类型定义一个新名字，这里的数据类型包括内部数据类型（int，char等）和自定义的数据类型（struct等）。 typedef本身是一种存储类的关键字，与auto、extern、static、register等关键字不能出现在同一个表达式中。 2. 作用及用法 2.1 typedef的用法 使用typedef定义新类型的方法：把关键字typedef加在变量声明表达式开头就行了。 下面以两个示例，描述ty
线性表学习总结（顺序表和链表）
qq_43627094的博客
09-29 760
线性表主要分为两种，顺序表和链表。 顺序表主要利用的是数组，大部分时候只需要重新定义数组的插入或删除操作就可以，所以顺序表的存储结构跟数组是相同的，都是一串连在一起的内存。因此，顺序表在存储数据的同时也保存了数据之间的逻辑关系。并且可以通过访问数组下标直接访问对应元素。这里主要总结链表。 链表是将内存中零散的不连续的部分连接在一起，这个起连接作用的东西就是指针。我们可以用过指针去访问已知的可以访问...
数据结构学习总结 ——4.线性表一链式存储结构
LuckyStar_D的博客
02-24 1007
线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存为被占用的任意位置。
线性表学习小结
灵谷鱼的博客
09-15 1746
线性表学习小结 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况...
关于线性表的学习总结
wind的博客
03-06 2149
定义：具有相同数据类型的n个数据元素的有限序列。 顺序表
头歌实践教学平台数据结构线性表双向链表
最新发布
10-20
头歌实践教学平台是一个教育平台，提供在线编程课程和实践项目。数据结构是计算机科学中的一个重要领域，线性表和双向链表是其中的两个基本概念。线性表是一种数据结构，其中数据元素按照线性顺序排列，每个元素都有一个前驱和一个后继。双向链表是一种特殊的线性表，每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点。这两种数据结构在实际编程中经常被使用，可以用来解决各种问题，例如数据的存储和检索等。 如果你想学习数据结构和算法，可以参考上面提到的 GitHub 项目，它们提供了很多有用的资源和教程。同时，你也可以在头歌实践教学平台上找到相关的课程和项目，进行实践和学习。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值