数据结构（第二章）线性表2——链表

最新推荐文章于 2022-05-31 19:27:10 发布
最新推荐文章于 2022-05-31 19:27:10 发布
阅读量420 收藏
点赞数 1
文章标签： 链表 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45280324/article/details/119257163
版权

数据结构（第二章）线性表2——链表

文章目录

一、单链表

链式存储：不要求逻辑相邻的元素在物理位置上也相邻，借助指示元素存储地址的指针来表示元素之间的逻辑关系

  • 优点：不会出现碎片现象，能充分利用所有存储单元
  • 缺点：每个元素因指针而占用额外的存储空间，且只能实现顺序存取

声明：

// 单链表结点的描述如下：
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

对比下边两种其实表达的含义一样
    LNode *L; // 声明一个指向单链表第一个节点的指针
	LinkList L; // 声明一个指向单链表第一个节点的指针（代码可读性更强）
前者强调为结点，后者强调为单链表，本质意义无区别

单链表有带头结点和不带头结点两类，实际应用中带头结点更为简单，下边将围绕着两种方式进行简单讨论：初始化、创建、增删改查

初始化

// 定义一个单链表
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList; 

// 初始化不带头结点的单链表
bool InitList1(LinkList &L){
	L= NULL;
	return true;
}
// 初始化带头结点的单链表
bool InitList(LinkList &L){
	L=(LNode *)malloc(sizeof(LNode)); //申请一个结点空间（头节点）
	if(L==NULL){
		return false; //申请内存空间失败
	}
	L->next=NULL;
	return true;
}

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

创建——头插法与尾插法

创建一个单链表——尾插法、头插法

// 尾插法建立单链表
/*如果每次都是从头指针开始遍历一直到找到最后一个元素在进行插入，这样的时间复杂度太高，建立表的时间复杂度达到O(n^2)。所以我们需要 设立一个尾指针，这样时间复杂度为O(n)*/
LinkList List_TailInsert(LinkList &L){ //尾插法建立头指针
	int x; //设置ElemType变量为整型
	L=(LinkList)malloc(sizeof(LNode));//等价于L=(LNode *)malloc(sizeof(LNode));——初始化操作
	LNode *s,*r=L; //定义两个指向结点的指针
	scanf("%d",&x); // 依次输入x的数值
	while(x != 521){ // 设置输入结束数值
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;
		scanf("%d",&x);
	}
	r->next=NULL; // 最后一个结点指向空
	return L; // 最后返回L
}


// 头插法——（在头结点之后插入结点，建立单链表）
// 这样输入的元素顺序与单链表的顺序相反——逆序操作！！！！！！！
LinkList List_HeadInsert(LinkList &L){
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	scanf("%d",&x);
	while(x != 521){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf("%d",&x);
	}
	return L;
}

插入

// 按位序插入操作（带头结点）
bool ListInsert(LinkList &L,int i,int e){ // 在第i个位置插入元素e
	if(i<1)
		return false;
	LNode *p;
	int j=0;
	p=L;
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	}
	if(p==NULL)
		return false; // 输出的i值过大，不合法
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}


// 按位序插入操作（不带头结点）
bool ListInsert1(LinkList &L,int i,int e){// 在第i个位置插入元素e
	if(i<1)
		return false;
	/*从这里显示出了不带头结点的链表的繁琐之处*/
	if(i==1){ //如果在第一个结点的位置上（其实是在当前链表的i位之前插入）需要特殊处理
		LNode *s=(LNode *)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L->next=s;
	}
	LNode *p;
	int j=1; // j=1
	p=L; // p指向第一个结点
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	}
	if(p==NULL)
		return false; // 输出的i值过大，不合法
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}

// 指定结点后插入
bool InsertNextNode(LNode *p,int e){ // 在p结点之后插入data为e的结点
	if(p==NULL)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL) //内存分配失败返回false
		return false;
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}


// 前插操作（在p结点之前插入元素e）
// 指定结点前插——需要从头结点开始遍历整个链表，但无疑会增大时间开销，我们采用一种简约的方式
bool InsertPriorNode(LNode *p,int e){
	if(p==NULL)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)
		return false;
	s->next=p->next; //先将结点s插入到p结点之后
	p->next=s;
	s->data=p->data; //s结点的data数值赋值为p中元素的数值
	p->data=e; // p中元素数值修改为e
}

删除

// 按照位序删除（带头结点）——头节点可以视为第0个结点
bool ListDelete(LinkList &L,int i,int &e){//删除表中第i个位置的元素，并用e返回删除元素的数值
	if(i<1)
		return false;
	LNode *p;
	p=L;
	int j=0;
	while(p!=NULL&&j<i-1){ // 找p结点的前驱
		p=p->next;
		j++;
	}
	if(p==NULL)
		return false; // 老规矩，p的值不合法
	if(p->next==NULL)
		return false; // 第i-1个结点为最后一个结点
	LNode *q=p->next;
	e=q->data;
	p->next=q->next;
	free(q);
	return true;
}

查找

// 查找
// 按位查找，返回第i个元素的数值（携带头结点）
LNode *GetElem(LinkList L,int i){
	if(i==0)
		return L;
	if(i<1)
		return NULL;
	LNode *p=L->next;
	int j=1;
	while(p!=NULL&&j<i){
		p=p->next;
		j++;
	}
	return p;

}

// 按值查找
LNode * LocateElem(LinkList L,int e){
	LNode *p=L->next;
	while(p->data!=e && p!=NULL)
		p=p->next;
	return p;
}

求表长

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

二、双链表

双链表结点的描述

// 双链表结点的描述
typedef struct DNode{
	ELemType data;
	struct DNode *next,*prior;
}DNode,*DLinklist;

初始化

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


// 双链表结点的描述
typedef struct DNode{
	int data;
	struct DNode *next,*prior;
}DNode,*DLinklist;

//带头结点的双链表的初始化——piror、next指针都指向空
bool InitDLinkList(DLinklist &L){
	L=(DNode *)malloc(sizeof(DNode));
	if(L==NULL)
		return false;
	L->prior=NULL;
	L->next=NULL;
	return true;
}

// 判断双链表是否为空
bool Empty(DLinklist L){
	if(L->next==NULL)
		return true;
	else
		return false;
}

插入

// 插入
// 在p结点之后插入结点s
bool InsertNextDNode(DNode *p,DNode *s){
	if(p==NULL || s==NULL){
		return false;
	}
	s->next=p->next;
	if(p->next != NULL){ // 判断p是否为最后一个结点
		p->next->prior=s; // 若不是，则将p结点的后继结点的前驱指针指向s
	}
	s->prior=p;
	p->next=s;
	return true;
}

删除

// 删除结点
// 头结点的删除——销毁表时才可以删除头结点
// 销毁表，需要删除所有结点
void DestoryList(DLinklist &L){
	while(L->next != NULL){
		DeleteNextDNode(L); // 删除L结点的后继结点
	}
	free(L);
	L=NULL; //头指针指向NULL
}


// 删除p结点的后继节点
bool DeleteNextDNode(DNode *p){
	if(p==NULL)
		return false;
	DNode *q=p->next;
	if(q==NULL)
		return false; // p结点的后继不存在
	p->next=q->next;
	if(q->next != NULL)
		q->next->prior=p; // q不是最后一个结点
	free(q);
	return true;
}

三、循环单链表

// 循环单链表
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;

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

// 循环单链表
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;

// 初始化
bool InitList(LinkList &L){
	L=(LNode *)malloc(sizeof(LNode));
	if(L == NULL)
		return false;
	L->next=L; // next指针指向自身
	return true;
}

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

// 判断结点怕是否为循环单链表的表尾结点
bool IsTail(LinkList L,LNode *p){
	if(p->next==L)
		return true;
	else
		return false;
}

四、循环双链表

// 循环双链表
typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,*DLinklist;

// 循环双链表
typedef struct DNode{
	int data;
	struct DNode *prior,*next;
}DNode,*DLinklist;

// 初始化
bool InitDLinklist(DLinklist &L){
	L=(DNode *)malloc(sizeof(LNode));
	if(L==NULL)
		return false;
	L->prior = L;
	L->next = L; 
	return true;
}

// 判空
bool Empty(DLinklist L){
	if(L->next==L)
		return true;
	else
		return false;
}

// 判断是否为表尾
bool IsTail(DLinklist L,DNode *p){
	if(p->next==L)
		return true;
	else
		return false;
}

// 插入
bool InsertNextDNode(DNode *p,DNode *s){
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;
	p->next=s;
}

// 删除
DNode *q=p->next;
p->next=q->next;
q->next->prior=p;
free(q);

五、静态链表

#define MaxSize 10
typedef struct{
	ElemType data;
	int next;
}SLinklList[MaxSize];

typedef不同的定义方式

#define MaxSize 10
typedef struct{
	int data;
	int next;
}SLinklList[MaxSize];

#define MaxSize 10 // 这两种定义方式等价
struct Node{
	int data;
	int next;
};
typedef struct Node SLinklList[MaxSize];
// ————————————————————————————————————————————————————- 
SLinklList a; //等价于下式
struct Node a[MaxSize];

SLinklList a; ——相当于定义了一个长度为MaxSize的Node型数组

操作：

  • 查找：从头结点出发挨个往后遍历
  • 插入位序为i的结点：
    ①找到一个空结点，存入数据元素
    ②从头结点出发找到位序为i-1的结点
    ③修改新结点的next
    ④修改i-1号结点的next
    如何判断结点为空？让其next为某个特殊值，比如-3
  • 删除某个结点：
    ①从头结点出发找到前驱结点
    ②修改前驱结点的游标
    ③本删除结点next设置为-3

顺序表和链表的比较

  1. 逻辑结构：都属于线性表，都是线性结构
  2. 存储结构：
    顺序表：优点：支持随机存取、存储密度高；缺点：大片连续空间分配不方便，改变容量不方便
    链表：优点：离散的小空间分配方便，改变容量方便；缺点：不可随机存取，存储密度低
    1. 基本操作：创建、销毁、增删改查
    2. 创建
      • 顺序表：需要分配大片连续空间，若分配空间国校，则之后不方便扩展容量；若分配空间过大，则浪费内存资源；（静态分配：静态数组——容量不可更改；动态分配——动态数组（malloc、free）——容量可以更改，但需要引动大量元素、时间代价高）
      • 链表：只需要分配一个头节点（也可以不要头节点，只声明一个头指针），之后方便拓展
    3. 销毁
      • 顺序表：修改Length=0（静态分配：静态数组——系统自动回收空间；动态分配——动态数组（malloc、free）——需要手动free）
      • 链表：依次删除各个节点（free）
        • 注：有malloc创建的空间属于堆区，系统不会自动回收，因此malloc和free必须成对出现
    4. 增、删
      • 顺序表：插入/删除元素要将后续元素都后移/前移（时间复杂度O(n)，时间开销只要来自于移动元素——如果数据元素很大，则移动的时间代价很高）
      • 链表：插入/删除元素只需要修改指针即可（时间复杂度O(n)，时间开销只要来查找目标元素——查找元素的时间代价更低）
    5. 查找
      • 顺序表：按位查找：O(1)；按值查找：O(n)，若表内元素有序，可在 O ( l o g 2 n ) O(log_2^n) O(log2n​)（折半等查找方法）时间内找到
      • 链表：按位查找、按值查找：O(n)
☆✎ℳ㎕ζั蓦❦☆
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法随笔 — 线性表基础 — 链表
TM_Godspeed的博客
03-09 263
本文将会讲述单链表的基本定义及实现方式和几道LeetCode上的相关习题
《数据结构》阶段性测试1
notqq555的博客
04-12 3417
6-1 十进制转二进制（顺序栈设计和应用） 7-1 两个有序序列的中位数
数据结构之链表
蛟~
09-28 252
基础概念 相当于顺序表来说，链式线性表的存储结构要求就没有那么高，可以是一组任意的存储单元。这样也就需要用指针来将前后的元素连接起来，因此就有结点这个概念，就是一个结点不仅包含自身的数据，还包括下一个元素的地址（即指针）。 但链表有一个缺点，就是： 访问链表中的元素，只能从头指针开始一个一个地向下找。 头指针就是指向第一个元素数据域的指针，但很多时候，我们会加入一个头结点，使得头指针指向头结点，头结点的数据域不放东西，指针域放首元结点(第一个元素）的数据域地址。 代码实现 单链表的存储结构： //单链表的存
数据结构学习日志之三--静态链表
chanbendong的博客
03-14 391
当链表每个节点在物理位置上是相邻的，即用数组描述的链表叫静态链表假设S为静态链表，S[0].cur只是第一个结点在数组中的位置，若设i = S[0].cur，S[i].data存储静态链表中的第一个数据元素，S[i].cur表示第二个结点在数组中的位置。一般情况下，若第i个分量表示静态链表的第k个结点，则S[i].cur表示第k+1个结点在数组中的位置。以整型游标i代替动态指针，i = S[i]....
【数据结构】链表及之小白篇
WYL_1_2_3的博客
06-09 227
线性表在逻辑相邻且在物理上相邻，他们各个元素之间的地址都是连续的。而链表，顾名思义逻辑相邻的两个元素在物理上是不相邻的，元素之间地址不连续。 链表与线性表的优缺点： 线性表优点： 物理位置连续，可以快速存取线性表中任意位置的元素；查找效率高； 线性表缺点： 插入或删除需要移动大量的元素，效率低;线性表长度难以确定；可能浪费内存；数组大小固定，不能动态扩展；内存要求较高，需要足够且连续的内存空间； 链表优点： 插入删除无需移动数据，效率高；内存利用率高，不会浪费；大小没有固定，拓.
数据结构PTA判断题（最全）
热门推荐
琉璃轻纱的博客
06-04 1万+
绪论 1、 2N和N​N​​具有相同的增长速度。(5分) F 2、算法分析的两个主要方面是时间复杂度和空间复杂度的分析。(5分) T 3、算法可以没有输入，但是必须有输出。 T 4、数据的逻辑结构是指数据的各数据项之间的逻辑关系。 F 5、数据的逻辑结构说明数据元素之间的顺序关系，它依赖于计算机的存储结构。 F 6、(neuDS)数据的物理结构是指数据在计算机中的实际存储形式。 T 7、线性表中的所有数据元素的数据类型必须相同。 T 8、算法和程序没有区别，在数据结构中二者是通用
数据结构课后习题答案第二章 线性表.docx
最新发布
11-12
本章主要探讨了线性表的两种常见存储结构——顺序表和链表，以及它们各自的特点和适用场景。 首先，头指针、头结点和首元结点是链表中的关键概念。头指针是一个变量，它存储了链表中第一个结点的地址，用来标识整个...
数据结构第二章课程文档
10-21
本篇文档主要围绕数据结构中的一个重要概念——线性表展开，适用于教师教学和学生学习。 线性表是数据结构的基础类型之一，它是一个包含n个数据元素的有限序列，用符号表示为()。线性表具有以下特性： 1. 非空有限...
数据结构：第二章栈.ppt
09-17
1. **逻辑结构分析**：理解栈作为数据结构的抽象概念，包括其特性——后进先出。 2. **运算定义**：定义栈的基本操作，如初始化、判断栈是否为空、判断栈是否已满、获取栈顶元素、压栈和弹栈。 3. **运算实现（算法...
第二章++线性表.ppt
07-28
线性表是计算机科学中一种基础且重要的数据结构，它由n个相同特性的数据元素组成，这些元素在集合中按照特定的顺序排列。在本章中，我们深入探讨线性表的概念、类型定义以及其两种主要的实现方式——顺序表示和链式...
《数据结构》_PTA_数据结构作业1：绪论和线性表
国家一级致癌物
12-29 3887
判断题 1-1 T 1-2 T 1-3 An algorithm may or may not require input, but each algorithm is expected to produce at least one result as the output. T 1-4 T 1-5 F 1-6 F 1-7 T 算法分析的两个主要方面是时间复杂度和空间复杂度的分析。 1-8 T 对于顺序存储的长度为N的线性表，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。
（PTA）数据结构（作业）2、顺序表
Misasagi Inori的博客
03-20 1万+
作业，仅供参考，大佬轻喷，如有意见，那就是你对，谢谢
数据结构学习
wei1111111112的博客
07-02 819
数据结构 前言 提示：学习数据结构，扎实自己的算法基础，提升自己的编程思维 一、线性表 线性表是具有相同类型的n（n>=0）个元素的有限序列，其中n为表长，当n=0时，线性表是一个空表。用L命名线性表，则其一般表示为： L = ( a1,a2,a3,..,ai,ai+1,...,an ) 式中a1是唯一一个“第一个”数据元素，又称为表头元素，an是“最后一个”数据元素，又称表尾元素。除第一个元素之外，每个元素有且只有一个直接前驱，除最...
【数据结构】顺序表与链表的比较
WINGREZ‘S BLOG
07-31 6966
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 1、存取方式 顺序表支持随机存取，而链表不支持，它只能从表头按顺序存取元素。 2、逻辑结构与存储结构 在顺序表中，逻...
数据结构与算法分析——第1~2章考试题
m553366999的博客
01-02 8311
判断题 1-1 The Fibonacci number sequence {FN​} is defined as: F0​=0, F1​=1, FN​=FN−1​+FN−2​, N=2, 3, .... The time complexity of the function which calculates FN​ recursively is Θ(N!).(3分) TF 作者 DS课程组 单位 浙江大学 1-2 (logn)2 is O(n).(2分) T...
数据结构学习笔记（一）
qq_43610272的博客
10-04 473
数据结构学习笔记（一） 这一学期开始学习数据结构，计划记录总结一下自己学到的内容。这一段时间主要学习了线性表。 1.顺序表 顺序表即线性表的顺序表示，是用一组地址连续的存储单元一次存储线性表的数据元素，满足： LOC(ai+1) = LOC(ai) + l; LOC(ai) = LOC(a0) + (i - 1) * l l是单个数据元素所占用的存储单元。 顺序表中逻辑上相邻的元素在物理位置上也是...
数据结构复习（二）线性表①
qq_46113775的博客
05-31 500
线性表相关内容
数据结构：链表与逻辑问题
Kobe51920的博客
08-18 2731
优点 缺点 链表 1.用多少开多少，直接链上去，没有空间浪费 2.头尾插入效率高 O(1) 不支持随机访问，顺序访问 顺序表 1.支持随机访问,随机访问 1.增容时成倍增长，有空间浪费 2.中间或者头部插入数据时效率不高 O(N) ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值