数据结构与算法——线性表（链表篇）_线性链表

2401_84182906

于 2024-05-01 07:34:14 发布

阅读量309

点赞数 10

分类专栏：程序员文章标签：链表数据结构

本文链接：https://blog.csdn.net/2401_84182906/article/details/138365433

版权

程序员专栏收录该内容

124 篇文章 1 订阅

订阅专栏

本文详细介绍了线性表的链式存储结构，特别是单链表的创建、节点操作（插入、删除和查找），以及动态链表和双向链表的区别和基本操作。重点讨论了按位查找和头结点的作用，以及链表与顺序存储结构的对比。

摘要由CSDN通过智能技术生成

		* [👻查找操作（带头结点）](#_336)
		* + [⛅按位查找操作](#_337)
			+ [⛅按值查找操作](#_365)
		* [👻单链表的创建](#_388)
		* + [⛅尾插法](#_389)
			+ [⛅头插法](#_412)
	- [🚢静态链表](#_437)
	- [🚢循环链表](#_451)
	- [🚢双向链表](#_470)
	- * [👻双向链表的初始化（带头结点）](#_488)
		* [👻双向链表的插入操作](#_515)
		* [👻双向链表的删除操作](#_542)
+ [💻总结](#_570)

🚀前言

上一文数据结构与算法——线性表（顺序表篇）中详细介绍了线性表的顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以随机存取表中的任一元素，它的存储位置可用一个简单直观的公式来表示。

但是，从另外一方面来看，线性表顺序存储的特点也构成了这种存储结构的特点：在做插入和删除操作时，需要移动大量元素。

在这里插入图片描述

本篇文章，我将详细介绍线性表的另外一种表示方式——链式存储结构。由于链式存储结构不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构所具有的弱点，但同时也失去了顺序表可随机存取的优势

🚀线性链表（单链表）

🚢概念

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的），因此，为了表示某个数据元素

ai与它的直接后继元素

ai+1

ai+1之间的逻辑关系，对数据元素

ai来说，除存储其本身的信息之外，还需要存储一个指示它直接后继的信息（即直接后继的存储位置），这两部分信息组成数据元素

ai的存储映像，称为结点（node）。

它包括两个域：其中存储数据元素信息的域称为数据域，存储直接后继存储位置的域称为指针域，指针域中存储的信息称为指针或链，

n个结点（

ai(1<=i<=n)的存储映像）链结成一个链表，即为线性表的链式存储结构

在这里插入图片描述

由于链表的每个结点中只包含一个指针域，所以又称这种链表为线性链表或单链表，整个链表的存取必须从头指针开始进行，头指针指示链表中的第一个结点（即第一个数据元素的存储映像）的存储位置，同时，由于最后一个数据元素没有直接后继，则线性链表中最后一个结点的指针为空（NULL）

单链表的定义：

//方式一
typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList  


//方式二
struct LNode{                   //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
};
typedef struct LNode LNode;
typedef struct LNode \*LinkList;

用线性链表表示线性表时，数据元素之间的逻辑关系是由结点中的指针指示的，换句话说，指针为数据元素之间的逻辑关系的映像，则逻辑上相邻的两个数据元素其存储的物理位置不要求紧邻，由此可得出，这种存储结构为非顺序映像或链式映像。

在这里插入图片描述

通常我们把链表画成用箭头相连接的结点的序列，结点之间的箭头表示链域中的指针，它所表是的线性表中数据元素之间的逻辑顺序，而不是每个数据元素在存储器中的实际位置

一般在一个单链表中，L表示为单链表的头指针，它指向表中的第一个结点，若L为‘空’（L=NULL），则所表示的线性表为‘空表’，其长度n为‘零’。

带头结点的单链表初始化：

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//初始化一个单链表(带头结点)
bool InitList(LinkList &L){
    L = (LNode \*)malloc(sizeof(LNode));     //分配一个头结点
    if(L == NULL){          //内存不足，分配失败
        return false;
    }
    L->next = NULL;         //头结点之后暂时还没有结点
    return true;
}

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

在单链表的第一个结点之前附设一个结点，称之为头结点。头结点的数据域可以不存储任何信息，也可以存储如线性表的长度等类的附加信息，头结点的指针域存储指向第一个结点的指针（即第一个元素结点的存储位置），单链表的头指针指向头结点。若线性表为空表，则头结点的指针域为‘空’。头结点的作用在于便于边缘化处理（好写程序），头结点也可以不写。

不带头结点的单链表初始化：

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

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

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

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

在线性表的顺序存储结构中，由于逻辑上相邻的两个元素在物理位置上也相邻，则每个元素的存储位置都可以从线性表的起始位置计算得到，而在单链表中，任何两个元素的存储位置之间没有固定的联系，要想取得第

i个数据元素必须从头指针出发寻找，因此，单链表是非随机存储结构。

单链表的局限性：无法逆向检索，有时候不方便

🚢基本操作

👻插入操作

⛅按位序插入

插入操作，在表L中的第

i个位置上插入指定元素

想要在第i个位置上插入元素，那么就要找到第

−

i-1

i−1个结点，然后将新结点插入其后面

带头结点情况：

在这里插入图片描述

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1){
        return false;
    }
    LNode \*p;       //指针p指向当前扫描的结点
    int j=0;        //当前p指针的是第几个结点
    while (p != NULL && j<i-1){     //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL){  //i值不合法
        return false;
    }
    LNode \*t = (LNode \*)malloc(sizeof(LNode));
    t->data = e;
    t->next = p->next;
    p->next = t;        //将结点t连接到p之后
    return true;        //插入成功
}

不带头结点情况：
在这里插入图片描述

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1){
        return false;
    }
    if(i==1){
        LNode \*t = (LNode \*)malloc(sizeof(LNode));
        t->data = e;
        t->next = L;
        L = t:      //头指针指向新结点
        return true;
    }
    LNode \*p;       //指针p指向当前扫描的结点
    int j = 1;      //当前p指向的是第几个结点
    p = L;          //p指向第一个结点(注意：不是头结点)
    while(p != NULL && j<i-1){      //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL){      //i值不合法
        return false;
    }
    LNode \*t = (LNode \*)malloc(sizeof(LNode));
    t->data = e;
    t->next = p->next;
    p->next = t;
    return true;        //插入成功
}

当i=1时，执行插入操作所需要的时间复杂度为

(

)

(

)

T(n) = O(1)

T(n)=O(1)
当i>1 && i<=n时，时间复杂度为

(

)

(

)

T(n)=O(n)

但是，值得注意的是，实际上插入这个操作真正时间复杂度为

(

)

(

)

T(n)=O(1)

T(n)=O(1)，而程序运行所耗费的时间都在找到要插入的元素位置的前一个位置，所以综合考究:

**📌平均时间复杂为

T

(

n

)

=

O

(

n

)

T(n) = O(n)

T(n)=O(n)**

⛅指定结点的后插操作

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode \*p, ElemType e){
    if(p == NULL){
        return false;
    }
    LNode \*t = (LNode \*)malloc(sizeof(LNode));
    if(s==NULL){        //内存分配失败
        return false;
    }
    t->data = e;        //用结点t保存数据元素e
    t->next = p->next;
    p->next = t         //将结点t连接到p之后
    return true;
}

**📌平均时间复杂度为

T

(

o

)

=

N

(

1

)

T(o) = N(1)

T(o)=N(1)**

⛅指定节点的前插操作

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//后插操作：在p结点之前插入元素e
bool InsertNextNode(LNode \*p, ElemType e){
    if(p == NULL){
        return false;
    }
    LNode \*t = (LNode \*)malloc(sizeof(LNode));
    if(s==NULL){        //内存分配失败
        return false;
    }
    t->next = p->next;
    p->next = t;            //新结点t连接到p之后
    t->data = p->data;      //将p中元素复制到t中
    p->data = e;            //p中元素覆盖为e
}

**📌平均时间复杂度为

T

(

o

)

=

n

(

1

)

T(o) = n(1)

T(o)=n(1)**

👻删除操作

删除操作。删除表L中第

i个位置的元素，并用

e返回删除元素的值
在这里插入图片描述

⛅按位序删除

带头结点情况：

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//带头结点的删除操作
bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i<1){
        return false;
    }
    LNode \*p;       //指针p指向当前扫描到的结点
    int j=0;        //当前p指向的是第几个结点
    p = L;          //L指向头结点，头结点是第0个结点(不存数据)
    while(p != NULL && j<i-1){      //循环找到第i-1个结点
        p = P->next;
        j++;
    }
    if(p == NULL){      //i值不合法
        return false;
    }
    if(p->next == NULL){        //第i-1个结点之后已无其他结点
        return false;
    }
    LNode \*q = P->next;         //令q指向被删除结点
    e = q->data;                //用e返回元素的值
    p->next = q->next;          //将\*q结点从链中断开
    free(q);                    //释放结点的存储空间
    return true;                //删除成功
}

**📌在删除操作中，最坏和平均时间复杂度为

T

(

o

)

=

o

(

n

)

T(o) = o(n)

T(o)=o(n)**

最好时间复杂度:

(

)

(

)

T(n) = O(1)

T(n)=O(1)

⛅指定节点的删除

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//删除指定结点p
bool DeleteNode(LNode \*p){
    if(p == NULL){
        return false;
    }
    LNode \*q = p->next;     //令q指向\*p的后继结点
    p->data = p->next->data //和后继结点交换数据域
    p->next = q->next;      //将\*q结点从链中断开
    free(q);                //释放后继结点的存储空间
    return true;
}

但是，使用这个算法有个问题，如果p是最后一个结点，那么当程序执行到p->data = p->next->data这一句时，会出现空指针的错误，所以只能从表头开始依次寻找p的前驱

**📌时间复杂度为

T

(

n

)

=

O

(

n

)

T(n) = O(n)

T(n)=O(n)**

👻查找操作（带头结点）

⛅按位查找操作

按位查找操作。获取表L中第i个位置的元素的值

typedef struct LNode{           //定义单链表节点类型
    ElemType data;              //每个节点存放一个数据元素 
    struct LNode \*next;         //指针指向下一个节点 
}LNode, \*LinkList               

//按位查找，返回第i个元素(带头结点)
LNode \* GetElem(LinkList L, int i){
    if(i<0){
        return NULL;
    }
    LNode \*p;       //指针p指向当前扫描的结点
    int j = 0;      //当前p指向的是第几个结点
    p = L;          //L指向头结点，头结点是第0个结点(不存数据)
    while(p != NULL && j<i){        //循环找到第i个结点


![img](https://img-blog.csdnimg.cn/img_convert/482b8581fc75576a889d8aa40ce627e0.png)
![img](https://img-blog.csdnimg.cn/img_convert/b53ed35b6409b6e101abb343364a2c2a.png)
![img](https://img-blog.csdnimg.cn/img_convert/65c4775ff012b5330f8f8f4a333cd8bd.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  T(n) = O(n) 
>  
>  
>  T(n)=O(n)**
> 
> 
> 


  

##### 👻查找操作（带头结点）


###### ⛅按位查找操作


`按位查找操作`。获取表L中第i个位置的元素的值

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//按位查找，返回第i个元素(带头结点)
LNode * GetElem(LinkList L, int i){
if(i<0){
return NULL;
}
LNode *p; //指针p指向当前扫描的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点(不存数据)
while(p != NULL && j<i){ //循环找到第i个结点

[外链图片转存中…(img-m6fLenwQ-1714520004840)]
[外链图片转存中…(img-ojRaBryh-1714520004840)]
[外链图片转存中…(img-Bgj1nAz7-1714520004840)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

2401_84182906

关注

10
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
数据结构与算法——线性表（链表篇）_线性链表

上一文数据结构与算法——线性表（顺序表篇）中详细介绍了线性表的顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以随机存取表中的任一元素，它的存储位置可用一个简单直观的公式来表示。在做插入和删除操作时，需要移动大量元素。本篇文章，我将详细介绍线性表的另外一种表示方式——链式存储结构。由于链式存储结构不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构所具有的弱点，但同时也失去了顺序表可随机存取的优势。
复制链接

扫一扫