双链表（线性表的链式存储）---C语言版

最新推荐文章于 2023-03-12 09:04:32 发布
最新推荐文章于 2023-03-12 09:04:32 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47138646/article/details/121681648
版权

目录

双链表（线性表的链式存储）—C语言版

单链表结点中只有一个指向其后继结点的指针，使得单链表只能从头结点依次顺序地向后遍历。
要访问某个结点的前驱结点，只能从头开始遍历。
也就是说：访问后继结点的时间复杂度为O(1),访问前驱结点的时间复杂度为O(n)

为了克服单链表的上述缺点，引入了双链表。
双链表中有两个指针prior和next，分别指向其前驱结点和后继结点

一、双链表的定义

定义
仍旧使用该例子，我们要如何存储该表呢？

idnamedescription
1史强最强辅助
2章北海我不需要钢印，我是自己思想的主人
3罗辑人类不感谢罗辑
4维德失去人性，失去很多。失去兽性，失去一切

步骤一：声明数据元素类型

首先我们使用结构体声明数据元素（对应表中的一行数据）的类型

typedef struct{
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}ElemType;//此处的ElemType是个类型名

步骤二：声明结点
双链表中结点定义如下：

typedef struct DNode{
    ElemType data;//数据域
    struct DNode *prior;//前驱指针
    struct DNode *next;//后继指针
}DNode,*DLinkList;

双链表逻辑示意图：
在这里插入图片描述

二、双链表上具体操作的实现和时间复杂度

使用含头结点的双链表

1、初始化表。构造一个空表。
/*初始化*/
int InitList_DLink(DLinkList *L){
    *L=(DLinkList)malloc(sizeof(DNode));//创建头结点，并让头指针指向头结点
    if (!(*L)) return FALSE;//分配失败
    (*L)->prior=NULL;//头结点的prior永远指向NULL
    (*L)->next=NULL;//初始化为空
    return TRUE;//初始化成功
}

空表：
在这里插入图片描述

时间复杂度：

时间复杂度为O(1)

2、根据数组创建双链表（头插法和尾插法）

1.头插法

/*头插法创建双链表*/
int create_HeadInsert(DLinkList *L,ElemType a[],int n){
 // InitList_DLink(L);
    DNode *s;//用来指示新创建的结点
    int i;
    for(i=n-1;i>=0;i--){//由于D头插法是倒序插入，所以这里我们从数组最后开始遍历
        s=(DLinkList)malloc(sizeof(DNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        s->next=(*L)->next;//让该结点的后继指向第一个结点
        if((*L)->next!=NULL) (*L)->next->prior=s;//第一个结点的前驱指向该结点
        s->prior=(*L);//让该结点的前驱指向头结点   
        (*L)->next=s;//让头结点指向该D结点（该结点成为第一个结点）
    }
}

如图所示：
在这里插入图片描述

2.尾插法

/*尾插法创建双链表*/
int create_TailInsert(DLinkList *L,ElemType a[],int n){
 // InitList_DLink(L);
    DNode *s,*r=(*L); //s用来指示新创建的结点，r用来移动以连接链表
    int i;
    for(i=0;i<n;i++){//遍历数组
        s=(DLinkList)malloc(sizeof(DNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        r->next=s;//r始终指向链表的尾端，这里将新结点连接到r的后面
        s->prior=r;//该结点的前驱指向r指向的结点
        r=s;//r移动到链表尾端o
    }
    r->next=NULL;//结束时，最后一个结点的指针域赋值为空
}

如图所示：
在这里插入图片描述

时间复杂度：

每个结点插入的时间为O(1),设表长为n
所有方式的时间复杂度均为O(n)

3、插入操作。在表L中的第i个位置上插入指定元素e。
/*插入*/
int ListInsert_DLink(DLinkList *L,int i,ElemType e){
    int j=0;//空表序号为0
    DNode *p=(*L);//p指向头结点
    DNode *s;//s用来指示新创建的结点
    while (p&&j<i-1){//找到被插入序号的前一个位置
       p=p->next;//向后移动一个
       j++; 
    }
    if(!p||i<1) return FALSE;//序号在无效范围内
    s=(DLinkList)malloc(sizeof(DNode));//创建一个新结点
    s->data=e;//赋值
    s->next=p->next;//让该结点指向p（插入位置的前一个结点）的下一个结点
    if (p->next!=NULL) p->next->prior=s;//让p的下一个结点的前驱指向该结点
    s->prior=p;//让该结点的前D驱指向p
    p->next=s; //让p指向该结点  
}

如图所示：
在这里插入图片描述

时间复杂度：

在给定的结点后插入新结点的时间复杂度为O(1)
查找第i-1个节点的时间复杂度为O(n)
综上：时间复杂度为O(n)

4、删除操作。删除表中L中第i个位置的元素，并用e返回删除的元素。
/*删除*/
int ListDelete_DLink(DLinkList *L,int i,ElemType *e){
    int j=0;//空表序号为0
    DNode *p=(*L);//p指向头结点
    DNode *q;//q用来指向被删除的结点
    while (p->next&&j<i-1){//找到要被删除结点的前一个结点
        p=p->next;//向后移动一个
        j++;
    }
    if (!(p->next)||i<1) return FALSE;//序号在无效范围内
    q=p->next;//让q指向被删除的结点
    p->next=q->next;//让p（被删除结点的前一个结点）指向被删除结点的下一个结点，q从链表中断开
    if(q->next!=NULL)q->next->prior=p;
    *e=q->data;//把被删除的结点的值返回
    free(q);//释放该结点
    return TRUE; //删除成功
}

如图所示：
在这里插入图片描述

时间复杂度：

在给定的结点后删除结点的时间复杂度为O(1)
查找第i-1个节点的时间复杂度为O(n)
综上：时间复杂度为O(n)

其他操作与单链表一样，不展示

三、完整代码实现

#include<stdio.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0

typedef struct{
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}ElemType;//此处的ElemType是个类型名

typedef struct DNode{
    ElemType data;//数据域
    struct DNode *prior;//前驱指针
    struct DNode *next;//后继指针
}DNode,*DLinkList;

/*初始化*/
int InitList_DLink(DLinkList *L){
    *L=(DLinkList)malloc(sizeof(DNode));//创建头结点，并让头指针指向头结点
    if (!(*L)) return FALSE;//分配失败
    (*L)->prior=NULL;//头结点的prior永远指向NULL
    (*L)->next=NULL;//初始化为空
    return TRUE;//初始化成功
}

/*头插法创建双链表*/
int create_HeadInsert(DLinkList *L,ElemType a[],int n){
 // InitList_DLink(L);
    DNode *s;//用来指示新创建的结点
    int i;
    for(i=n-1;i>=0;i--){//由于D头插法是倒序插入，所以这里我们从数组最后开始遍历
        s=(DLinkList)malloc(sizeof(DNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        s->next=(*L)->next;//让该结点的后继指向第一个结点
        if((*L)->next!=NULL) (*L)->next->prior=s;//第一个结点的前驱指向该结点
        s->prior=(*L);//让该结点的前驱指向头结点   
        (*L)->next=s;//让头结点指向该D结点（该结点成为第一个结点）
    }
}

/*尾插法创建双链表*/
int create_TailInsert(DLinkList *L,ElemType a[],int n){
 // InitList_DLink(L);
    DNode *s,*r=(*L); //s用来指示新创建的结点，r用来移动以连接链表
    int i;
    for(i=0;i<n;i++){//遍历数组
        s=(DLinkList)malloc(sizeof(DNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        r->next=s;//r始终指向链表的尾端，这里将新结点连接到r的后面
        s->prior=r;//该结点的前驱指向r指向的结点
        r=s;//r移动到链表尾端o
    }
    r->next=NULL;//结束时，最后一个结点的指针域赋值为空
}

/*求表长*/
int Length_DLink(DLinkList L){
    int i=0;//空表返回0
    while (L->next!=NULL){//遍历，直到尾结点，空表不进入循环
        L=L->next;//向后移动一个
        i++;//表长加一
    }
    return i;//返回表长
}

/*插入*/
int ListInsert_DLink(DLinkList *L,int i,ElemType e){
    int j=0;//空表序号为0
    DNode *p=(*L);//p指向头结点
    DNode *s;//s用来指示新创建的结点
    while (p&&j<i-1){//找到被插入序号的前一个位置
       p=p->next;//向后移动一个
       j++; 
    }
    if(!p||i<1) return FALSE;//序号在无效范围内
    s=(DLinkList)malloc(sizeof(DNode));//创建一个新结点
    s->data=e;//赋值
    s->next=p->next;//让该结点指向p（插入位置的前一个结点）的下一个结点
    if (p->next!=NULL) p->next->prior=s;//让p的下一个结点的前驱指向该结点
    s->prior=p;//让该结点的前D驱指向p
    p->next=s; //让p指向该结点  
}

/*删除*/
int ListDelete_DLink(DLinkList *L,int i,ElemType *e){
    int j=0;//空表序号为0
    DNode *p=(*L);//p指向头结点
    DNode *q;//q用来指向被删除的结点
    while (p->next&&j<i-1){//找到要被删除结点的前一个结点
        p=p->next;//向后移动一个
        j++;
    }
    if (!(p->next)||i<1) return FALSE;//序号在无效范围内
    q=p->next;//让q指向被删除的结点
    p->next=q->next;//让p（被删除结点的前一个结点）指向被删除结点的下一个结点，q从链表中断开
    if(q->next!=NULL)q->next->prior=p;
    *e=q->data;//把被删除的结点的值返回
    free(q);//释放该结点
    return TRUE; //删除成功
}

/*按位查找*/
int GetElem_DList(DLinkList L,int i,ElemType *e){
    DNode *p=L; //p指向头结点
    int j=0;//空表序号为0
    while (p&&j<i){//找到第i个位置
        p=p->next;//向后移动一个
        ++j;
    }
    if(!(p)||i<1)  return FALSE; //i不在有效范围内
    *e=p->data; //把第i个结点的值用e返回
    return TRUE;
}

/*按值查找*/
int LocateElem_DList(DLinkList L,ElemType e,int *i){
    int j=0;//空表序号为0
    while (L->next!=NULL){//遍历链表
        L=L->next;//向后移动
        j++;//序号加一
        if (L->data.id==e.id){//这里我们只用id来判断元素的值是否相等，假设id唯一
            *i=j;//如果相等，用i返回序号
            return TRUE;//查找成功
        }    
    }
    return FALSE;
}

/*打印*/
void PrintList_DLink(DLinkList L){
    int i=0;//空表序号为0
    while (L->next!=NULL)//遍历表
    {
        L=L->next;
        i++;
        printf("第%d行：id=%d,name=%s,description=%s\n",i,L->data.id,L->data.name,L->data.description);
    }
}

/*销毁双链表*/
void DestroyDList(DLinkList *L){
    while((*L)->next!=NULL) {//遍历
    	DNode *p=(*L)->next;
    	(*L)->next=p->next;
        if(p->next!=NULL) p->next->prior=(*L);
    	free(p);
	}
}

int main(){
    DLinkList L;
    int i=InitList_DLink(&L);
    if(i==1){
        printf("初始化成功\n");
    }
    printf("\n");    
///
    ElemType a[4]={
        {1,"史强","最强辅助"},
        {2,"章北海","我不需要钢印，我是自己思想的主人"},
        {3,"罗辑","人类不感谢罗辑"},
        {4,"维德","失去人性，失去很多。失去兽性，失去一切"}
    };  
    //create_HeadInsert(&L,a,4);
    create_TailInsert(&L,a,4);  
    PrintList_DLink(L);
    printf("\n");    
///
    ElemType e={5,"xxx","xxxxxxxxxxxxxxxxxxxx"};
    ListInsert_DLink(&L,5,e); 
    PrintList_DLink(L);
    printf("\n");    
///
    ListDelete_DLink(&L,5,&e);
    PrintList_DLink(L);
    printf("被删除的元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("\n");    
///
    GetElem_DList(L,4,&e);
    printf("查询到的元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("\n");    
//
    LocateElem_DList(L,a[2],&i);
    printf("查询到的位序为：%d\n",i);
    printf("\n");    

    i=Length_DLink(L);
    printf("表长为：%d\n",i);
    printf("\n");    
//
    DestroyDList(&L);
    PrintList_DLink(L);
}

运行结果：

初始化成功

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切
第5行：id=5,name=xxx,description=xxxxxxxxxxxxxxxxxxxx

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切
被删除的元素：id=5,name=xxx,description=xxxxxxxxxxxxxxxxxxxx

查询到的元素：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切

查询到的位序为：3

表长为：4
秋千水竹马道
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
全网最详细的-线性表的链式存储
12-26
在实现链式存储时，可以使用单链表、双链表或循环链表等不同的结构来实现。单链表包含一个指针域，指向下一个节点；双链表包含两个指针域，分别指向前一个节点和后一个节点；循环链表是一种特殊的链表，尾节点的指针...
【数据结构】之双向链表的复杂度分析
yang553566463的博客
11-26 8553
双向链表的复杂度分析 我们先看一下它的概念（来自百度百科）： 它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 和单向链表不同的是，双链表除了有一个指向下一节点的指针外，还有一个指向前一节点的指针，这也就意味着，双向链表能够快速找到前驱节点，也能快速找到后驱节点。 和单向链表相比，对于插入或删除指定节点的操作，因为单向链表需要从头遍历定位到这个节点的前驱节点，所以它的平均复杂度是O(n
单链表和双链表的删除和插入的时间复杂度分析
lxr_17的博客
08-11 7686
单链表和双链表的删除和插入的时间复杂度分析 单向链表要删除某一节点时，必须要先通过遍历的方式找到前驱节点（开发中大致分为两种删除方式:1.通过待删除节点序号2.按值查找）。若仅仅知道待删除节点，是不能知道前驱节点的，故单链表的增删操作复杂度为O(n)。 双链表（双向链表）知道要删除某一节点p时，获取其前驱节点q的方式为 q = p->prior，不必再进行遍历。故时间复杂度为O(1)。而若只知道待删除节点的序号，则依然要按序查找，时间复杂度仍为O(n)。 单、双链表的插入操作
数据结构——2双链表
小小魔姬
03-01 191
实现简单的双链表 结构体Node：前结点pre、后结点next、数据data 类DList：头结点head、尾结点last、长度len 主要功能有：添加（前插入、后插入、一般位置插入）、删除（前推出、后推出、值删除、位置删除）、查询（值查询、位置查询）、链表复制、打印、返回链表长度 时间复杂度： 1、添加 前插入：因为存在头结点head，时间复杂度为O(1) 后插入：因为存在尾结点last，时间复...
python：单链表、尾结点单链表、循环链表、双链表类的实现
weixin_39781462的博客
09-10 1138
不同链表的简单总结】 1.基本单链表--首端插入和删除时间复杂度为O(1)，定位操作和尾操作时间复杂度为O(n) 2.增加尾结点引用域的链接--首端、尾端插入和首端弹出元素时间复杂度为O(1),尾端删除时间复杂度为O(n) 3.循环单链表--首端和尾端插入和首端元素弹出时间复杂度为O(1) 4.双链表--两端插入和删除的时间复杂度为O(1) 链表的一些优点】 1.表结构是由一些链接起来...
【期末复习记录】数据结构（更新到查找）
weixin_61639349的博客
06-13 1491
平平无奇的期末复习杂货记录罢了 希望期末顺顺利利 奋斗3周 我要放暑假！！！
线性表--顺序表操作
12-12
这有线性表的操作:顺序存储,链存储结构, 单链表,顺序表,循环链表,双向链表
双向链表的增删改查
03-16
实现双向链表的增删改查功能，dos窗口输入输出，可运行，有注释
2.5线性表其它链式存储方式介绍
09-10
根据王红梅教材《数据结构》C++版，第二章线性表的第6讲。主要介绍线性表的链式存储方法中双链表和循环链表的基本知识。
双向链表的基本常用操作（创建、初始化、插入、删除、链表长度、查找指定元素的位置、链表的销毁） c语言 数据结构 超详细~~
weixin_54907221的博客
11-23 2145
/本程序中包含对双向链表的：：创建、初始化、插入、删除、链表长度、查找指定元素的位置以及双向链表的销毁/ #include<stdio.h> #include<stdlib.h> typedef int Elemtype; typedef struct linknode { Elemtype data; struct linknode* next; }Linknode,Linklist; //创建循环链表 Linknode create() { Linklist head = (Li
双链表初始化、头插、尾插、头删、尾删、任意位置插入和删除、判空、销毁、打印、查找操作
weixin_46153828的博客
03-14 966
ListNode* buyDListNode(LTDataType data) { ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); if (NULL == newNode) { assert(0); return NULL; } newNode->data = data; newNode->prev = NULL; newNode->next = NULL; return newNode; } .
在长度为n (n≥1)的循环双链表L中，在尾节点之后插入一个新结点的时间复杂度为( )。
m0_61123026的博客
05-09 1996
A. O(n^2) B.O(n) C.O(1) D.O(nlog2n) 答案：C 在长度为n (n≥1)的双链表L中，在尾节点之后插入一个新结点的时间复杂度为( )。 A. O(n^2) B.O(n) C.O(1) D.O(nlog2n) 答案：B
C语言数据结构篇——双链表的创建，插入，节点删除，打印等操作
热门推荐
Demo不是emo的博客
02-07 1万+
一般学习双链表都是在学习单链表之后，但单链表有一个缺点，就是无法访问前驱节点，需要查找某个已知节点的前一个节点时能再次从头遍历，就比较麻烦，那么，在节点中再加一个指针指向前驱节点的链表就称为双链表，再综合单链表的节点写法，那么双链表的写法就很简单了。数据节点包含一个数据域，两个指针（一个指向前驱节点，一个指向后驱节点）。大致图解如下： ...
C++实现双链表的创建、插入、删除、查询、遍历、销毁等基本操作
Qian_Qian_IT的博客
09-20 1323
C++实现双链表的创建、插入、删除、查询、遍历、销毁等基本操作
数据结构与算法系列（线性表篇）
西城风雨楼
03-26 2159
线性表之双向链表 一、双向链表简单介绍 双向链表是单链表的一种扩展，单链表中每一个节点只保存一个指针域，该指针域唯一的指向当前节点的直接后继，而双向链表在单链表节点类型的基础之上，额外增加了一个前驱指针域，该指针域指向当前节点的直接前驱，正是因为有了直接前驱指针，双向链表的插入和删除算法和单链表也略有不同 二、时间复杂度 2.1 查找数据元素 在双向链表中查找一个元素同样需要遍历链表中的元素，因此时间复杂度是O(N) 2.2 插入一个元素的时间复杂度 在双向链表中插入一个元素，时间复杂度是O(1)
严蔚敏数据结构C语言版——线性表的链式存储方式详细代码
NJ_zbx的博客
03-12 929
严蔚敏数据结构C语言版线性表的链式存储方式代码
线性表的链式存储(C代码实现)
ana35287的博客
01-21 632
线性表的链式存储结构 线性表的实现分顺序存储结构和链式存储结构。 线性表的链式存储结构又称单链表。 上一节我们学习了线性表的顺序存储结构，并实现解顺序存储的基本操作。 这一节我们来学习线性表链式存储结构，那我们再想象一下我为什么我们要引入链式存储结构，万物存在必有其道理 主要还是因为线性存储结构存在着这样一个问题：当我们需要插入和删除元素时，就必须挪动大量与之无关的元素，因为线...
双向链表的实现---数据结构学习（三）
weitxing的博客
08-02 668
在单链表中，每个节点只有一个指针指向它的直接后继，访问数据时只能沿着指针向前访问。若要访问某一节点的前驱节点，只能从头开始访问。为解决这一问题而引出了双向链表的概念。双向链表中的每个节点包含两个指针（prior和next）分别指向它的前驱和后继，从一个节点出发既可以访问它的后继节点，也可访问它的前驱节点。可大大节省访问前驱节点的时间。 本文主要实现双向链表的初始化、插入、删除和输出操作。实现
C 线性表的链式存储实现及插入、删除等操作示例
weixin_30239339的博客
08-13 831
一、链式存储的优势 线性表的存储可以通过顺序存储或链式存储实现，其中顺序存储基于数组实现(见本人上一篇博客)，在进行插入删除等操作时，需对表内某一部分元素逐个移动，效率较低。而链式结构不依赖于地址连续的存储空间，可以克服数组表现线性表的缺陷。 二、基于链式存储线性表的基本操作 2.1 PtrToLNode Creat(int length)：创建一个长度为length的线性表 //创建长度...
线性表的链式存储结构
最新发布
09-06
线性表的链式存储结构是使用链式方式将线性表中的元素存储起来。链表可以分为单链表、循环链表和双链表。在单链表中，每个结点都包含指向下一个结点的指针。循环链表是在单链表的基础上，将最后一个结点的指针指向头...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秋千水竹马道

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值