数据结构 3.链表

已于 2024-05-30 19:15:49 修改
阅读量390 收藏 3
点赞数 12
文章标签： 数据结构 链表
于 2024-05-29 20:33:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54346126/article/details/139298591
版权

顺序表（顺序存储）：

        优点：可随机存取，存储密度高   

        缺点：要求大片连续空间，改变容量不方便

单链表（链式存储）：

        优点：不要求大片连续空间，改变容量方便

        缺点：不可随机存取，要耗费一定空间存放指针

1.单链表

存储结构如下：

typedef struct Node{ //节点类型定义
    ElemType data;
    struct Node *next;
}Node,*LinkList;

 建立单链表：

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList; 

//初始化一个空的单链表（不带头节点） 
bool InitList(LinkList &L) {
	L=NULL;
	return true;
}
//初始化一个空的单链表（带头节点） 
void InitList(LinkList &L) {
	L=(LNode*)malloc(sizeof(LNode));//分配一个头节点 
	L->next=NULL;
}

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

插入（带头节点）：

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

插入（不带头节点）：

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

指定结点后插操作：

​
//后插操作
bool InsertNextNode(LNode *p,int e){
	if(p==NULL)
		return false;
	LNode *s=(LNode*)malloc(sizeof(LNode));
	if(s==NULL) //内存分配失败
		return false;
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true; 
​}

指定结点前插操作：

//前插操作
bool InsertPriortNode(LNode *p,LNode *s){
	if(p==NULL || s==NULL)
		return false;
	s->next=p->next;
	p->next=s;
	int temp = p->data;
	p->data=s->data;
	s->data=temp;
	return true; 
}

删除结点（带头节点）：

//在第i个位置删除元素 (带头结点)
bool ListDelete(LinkList &L,int i,int &e){
	if(i<1)
		return false;
	LNode *p; //p指向当前扫描到的结点
	int j=0; //当前p指向的是第几个结点
	p=L;
	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;  //删除元素的值
	p->next=q->next;//将*q结点断开
	free(q);  //释放节点的存储空间 
	return true;
}

删除指定结点：

//删除指定结点p
bool DeleteNode(LNode *p){
	if(p==NULL)
		return false;
	LNode *q=p->next;
	p->data=p->next->data;
	p->next=q->next;
	free(q);
	return true;
}

按位查找：

//按位查找
LNode * GetElem(LinkList L,int i){
	int j=1;
	LNode *p = L->next;
	if(i==0)
		return L;
	if(i<1)
		return NULL;
	while(p!=NULL&&j<i){
		p=p->next;
		j++;
	}
	return p;
}

按值查找：

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

表长（带头节点）：

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

尾插法建立单链表：

#include<stdio.h>
#include<malloc.h>

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList; 

//初始化单链表（带头节点） 
void InitList(LinkList &L) {
	L=(LNode*)malloc(sizeof(LNode));//分配一个头节点 
	L->next=NULL;
}
//尾插法建立单链表
void ListTailInsert(LinkList &L){
	int x;
	L=(LinkList)malloc(sizeof(LNode));//建立头节点
	LNode *s,*r=L;
	scanf("%d",&x);
	while(x!=0){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;
		scanf("%d",&x);
	} 
	r->next=NULL;
} 


int main(){
	LinkList L; //声明一个指向单链表的指针 
	//初始化一个空的单链表
	InitList(L);
	ListTailInsert(L);
	printf("number:");
	while(L->next!=NULL){
		L=L->next;
		printf("%d\t",L->data);
	}
	
}

结果：

12
13
14
15
0
number:12       13      14      15

头插法建立单链表：

#include<stdio.h>
#include<malloc.h>

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList; 

//初始化单链表（带头节点） 
void InitList(LinkList &L) {
	L=(LNode*)malloc(sizeof(LNode));//分配一个头节点 
	L->next=NULL;
}

//头插法建立单链表
void ListHeadInsert(LinkList &L){
	LNode *s;
	int x;
	scanf("%d",&x);
	while(x!=0){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf("%d",&x);
	} 
}

int main(){
	LinkList L; //声明一个指向单链表的指针 
	//初始化一个空的单链表
	InitList(L);
	ListHeadInsert(L);
	printf("number:");
	while(L->next!=NULL){
		L=L->next;
		printf("%d\t",L->data);
	}
	
}

结果：

11
12
13
14
15
0
number:15       14      13      12      11

2.双链表

存储结构：

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

初始化：

//初始化双链表
bool InitDLinkList(DLinkList &L){
	L=(DNode*)malloc(sizeof(DNode));
	if(L == NULL)
		return false;
	L->prior = NULL;
	L->next = NULL;
	return true;
}

双链表的插入：

//双链表的插入
bool InsertNextDNode(DNode *p,DNode *s){
	if(p==NULL||s==NULL)
		return false;
	s->next=p->next; //将结点*s插入到*p之后 
	if(p->next != NULL)
		p->next->prior=s;
	s->prior=p;
	p->next=s;
	return true;
}

双链表的删除：

//删除p结点的后继结点
bool DeleteNextNode(DNode *p){
	if(p==NULL)
		return false;
	DNode *q=p->next;
	if(q==NULL)
		return false;
	p->next=q->next;
	if(q->next!=NULL)
		q->next->prior=p;
	free(q);
	return true;
} 
//销毁操作
void Destroy(DLinkList &L){
	while(L->next!=NULL){
		DeleteNextNode(L);
	}
	free(L); //释放头节点 
	L=NULL;
}

3.循环链表

循环单链表：

//循环单链表
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=L;
	return true;
} 

//判断是否为空
bool isEmpty(LinkList L){
	return L->next == L;
} 
//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode *p){
	return p->next == L;
}

循环双链表：

//循环双链表
typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,*DLinkList; 
//初始化空的循环双链表
bool InitDLinkList(DLinkList &L){
	L=(DNode*)malloc(sizeof(DNode))
	if(L==NULL)
		return false;
	L->prior=L;
	L->next=L;
	return true;
} 
//判断是否为空
bool isEmpty(DLinkList L){
	return L->next == L;
} 
//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinkList L,LNode *p){
	return p->next == L;
}

4.静态链表

静态链表：定义一个较大的结构数组作为备用结点空间，当申请结点时，每个结点含有两个域，data域和next域，data域存放结点数据信息，next域不再是指针而是游标指示器

用数组的方式实现的链表

优点：增删操作不需要大量移动元素

缺点：不能随机存取，只能从头节点开始依次往后查找，容量固定不可变

//静态链表
#define MaxSize 10 //静态链表的最大长度 
typedef struct {
	ElemType data;  //存储数据元素 
	int next; 		//下一个元素的数组下标 
}SLinkList[MaxSize]; 


#define MaxSize 10 //静态链表的最大长度 
struct Node{
	ElemType data;  //存储数据元素 
	int next; 		//下一个元素的数组下标 
};
typedef struct Node SLinkList[MaxSize];

5.顺序表和链表比较

存储结构

顺序表：

        优点：支持随机存取，存储密度高

        缺点：大片连续空间分配不方便，改变容量不方便

链表：

        优点：离散的小空间分配方便，改变容量方便

        缺点：不可随机存取，存储密度低

表长难以预估，经常增加或删除元素-----链表

表长可以预估，查询操作较多----顺序表

For you ，a thousand times over
关注
  • 12
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构之——链表
xqx_999的博客
10-06 4405
链表的介绍，单链表和双向链表的接口实现。
数据结构3：链表
胖大xian
03-22 474
表的连式存储-链表 链表是线性表的一种存储形似。 1.链表的结构特点 值域链域 值域（数据域）：存储表元素值 链域（指针域）：存储后继结点的存储地址（值单向链表） 2.链式存储结构图 首指针（表头指针）：指向链表的第一个结点的指针变量。其值为首结点的存储地址。 表尾结点（最后一个结点）的链域值为空（NULL）**^**图中使用这个，表中使用NULL 链表就是表头指针和一串相继链接的结点的总称 3....
【数据结构】链表
热门推荐
knous
03-13 6万+
链表
数据结构之链表
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
01-18 3991
数据结构之链表
数据结构2.3：链表
weixin_43979650的博客
02-14 362
1.顺序表和链表不同 顺序表： 由系统提前分配一组连续的存储空间； 采用顺序存储的方式存储数据元素； 元素逻辑顺序与物理位置直接相关，可随机存取； 链表： 由存储结点创建时主动向系统申请存储空间； 结点之间通过指针链接； 元素逻辑顺序由指针链接顺序决定，与物理位置无关，仅能顺序存取； 2.链表解决的问题 在实际情况中，尤其在多任务操作系统里，某时刻会同时运行多个进程，这些进程会向系统申请大小不同的...
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
链表的数据结构学习.pdf
07-21
链表是一种重要的数据结构，它不同于数组的连续内存分配方式，链表的各个节点（即内存结构）通过指针相连，可以是不连续的。在链表中，节点由数据域和指针域组成，其中数据域存储具体的数据，指针域则存储指向下一个...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
数据结构—— 再探二叉树
hedhjd的博客
08-21 614
前面我们的完全二叉树和满二叉树是使用数组来存储，如果不是完全二叉树和满二叉树就不适合使用数组存储，更适合链式结构来存储二叉树是：1. 空树2. 非空：根结点，根结点的左子树、根结点的右子树组成的3.二叉树是递归结构二叉树是整棵树拆分为根和子树，然后拆分过的子树再作为根继续拆分，一直这样持续至最后一个没有子树的根在遍历之前先手搓一个二叉树的基础模板}BTNode;//node1的左和右指向node2和node4//node1的左指向node3。
牛客竞赛数据结构专题班树状数组、线段树练习题
Landing_on_Mars的博客
08-18 275
令 f[i][0/1] 表示从第 1 层的左边（0）或右边（1）到第 i 层的左边（0）或右边（1）的方案数。不能发现这个问题如果不带修改则可以用 dp+前缀和（矩阵乘法）解决，带修改则可以用线段树维护区间和。我们可以将每一层的转移状态用矩阵表示，
Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
最新发布
2301_80689220的博客
08-21 123
【代码】Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 459
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
【数据结构篇】~顺序表
旺小仔的博客
08-16 552
【数据结构篇】~顺序表
初阶数据结构之直接选择排序和快速排序
Mr_Xuhhh的博客
08-17 670
1.直接选择排序思考⾮常好理解，但是效率不是很好。实际中很少使⽤2.时间复杂度： O(N。
数据结构初阶——算法复杂度超详解
fhvyxyci的博客
08-15 1362
1.数据结构前言 1.1 数据结构 1.2 算法 2.算法效率 2.1 复杂度的概念 3. 时间复杂度 3.1 大O的渐进表示法 3.2 时间复杂度计算示例 示例1 示例2 示例3 示例4 示例5 示例6 示例7 4. 空间复杂度 4.1 空间复杂度计算示例 4.1.1 示例1 4.1.2 示例2 5. 常见复杂度对比 6.复杂度算法题——[旋转数组](https://leetcode.cn/problems/rotate-array/description/) 思路1 思路2 思路3
数据结构-堆(二叉树的特殊)-第四天
qq_33867768的博客
08-21 101
堆是一棵完全二叉树，根据成立条件可分为大顶堆和小顶堆。大（小）顶堆的堆顶元素是最大（小）的。堆（Heap）是一种特殊的完全二叉树数据结构，通常用于实现优先队列。它是一种完全二叉树，除了最后一层外，每一层都是完全填充的。最后一层的所有节点都尽可能地靠左排列。堆中的每个节点的值与其子节点的值之间有一定的关系，这取决于堆的类型。堆是一种高效的数据结构，通常用于实现优先队列和排序算法。
选择排序（直接选择排序与堆排序的比较）
qq_63074244的博客
08-18 905
1. 直接选择排序思考⾮常好理解，但是效率不是很好。实际中很少使用，思路是先进行遍历找到元最小的元素，然后与第一个进行交换 2. 时间复杂度：O（）3. 空间复杂度：O(1) 上述代码的时间复杂度为：O（），但是不是最完美的所以我们进行优化一下，但是优化后时间复杂度还是O（）。 这时就可以看出选择排序和冒泡排序的差别，冒泡排序优化后时间复杂度会进行改变但是选择排序就并不会改变。堆排序分为大根堆和小根堆两种方法，这两种方法主要区别的是升序还是降序。升序大根堆因为我们知道大根堆中最大位于堆顶的，经过
【数据结构篇顺序表】算法题
旺小仔的博客
08-17 885
【数据结构篇顺序表】算法题
1.(菜单)主程序；2.链表的建立；3.链表的数据节点插入；4.链表的数据节点删除；5.链表的节点数据输出
05-18
链表是一种数据结构，由多个节点组成，每个节点包含了一个数据项和指向下一个节点的指针。链表的建立通常包括以下步骤：定义节点结构体、分配内存、初始化节点、链接节点等。 3. 链表的数据节点插入是指向链表中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值