线性表(顺序表和链表)

最新推荐文章于 2024-07-09 18:04:44 发布
最新推荐文章于 2024-07-09 18:04:44 发布
阅读量251 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51153209/article/details/127476836
版权

线性表

线性表L可用二元组形式描述：

L = ( D , R ) L= (D,R) L=(D,R)

即线性表L包含数据元素集合D和关系集合R

D = a i ∣ a i ∈ d a t a t y p e , i = 0 , 1 , 2 , ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ n − 1 , n ≥ 0 D={ai | ai∈datatype ,i=0,1,2, ∙∙∙∙∙∙∙∙∙n-1 ,n≥0} D=ai∣ai∈datatype,i=0,1,2,∙∙∙∙∙∙∙∙∙n−1,n≥0

R = < a i , a i + 1 > ∣ a i , a i + 1 ∈ D , 0 ≤ i ≤ n − 2 R={<ai , ai+1> | ai , ai+1∈D, 0≤i≤n-2} R=<ai,ai+1>∣ai,ai+1∈D,0≤i≤n−2

​ 关系符<ai, ai+1>在这里称为有序对

​ 表示任意相邻的两个元素之间的一种先后次序关系

​ ai是ai+1的直接前驱, ai+1是ai的直接后继

线性表的特征

  • 对非空表,a0是表头,无前驱
  • an-1是表尾,无后继
  • 其它的每个元素ai有且仅有一个直接前驱ai-1和一个直接后继ai+1

线性表顺序存储（顺序表）

顺序存储结构的表示

​ 若将线性表 L = ( a 0 , a 1 , … … , a n − 1 ) L=(a0,a1, ……,an-1) L=(a0,a1,……,an−1)中的各元素依次存储于计算机一片连续的存储空间。

设 L o c ( a i ) Loc(ai) Loc(ai)为 a i ai ai的地址， L o c ( a 0 ) = b Loc(a0)=b Loc(a0)=b，每个元素占d个单元 则： L o c ( a i ) = b + i ∗ d Loc(ai)=b+i*d Loc(ai)=b+i∗d

顺序存储结构的特点

  • 逻辑上相邻的元素 ai, ai+1，其存储位置也是相邻的
  • 对数据元素ai的存取为随机存取或按地址存取
  • 存储密度高
  • 存储密度D=(数据结构中元素所占存储空间)/（整个数据结构所占空间）

顺序存储结构的不足

  • 对表的插入和删除等运算的时间复杂度较差

顺序表的构建（C语言）

在C语言中，可借助于一维数组类型来描述线性表的顺序存储结构

顺序表结构体
typedef struct {
	data_t data[N];
	int last;
}sqlist, *sqlink;
创建顺序表
sqlink list_create() {
	//malloc
	sqlink L;

    L =(sqlink)malloc(sizeof(sqlist));
    if (L == NULL) {
        printf("list malloc failed\n");
        return L;
    }

    //initialize
    memset(L, 0, sizeof(sqlist));
    L->last = -1;

    //return
    return L;
}
清空顺序表
/*
 * @ret   0-success   -1-failed
 * */
   int list_clear(sqlink L) {
   if (L == NULL)
   	return -1;

   memset(L, 0, sizeof(sqlist));
   L->last = -1;

   return 0;
   }
删除顺序表
int list_delete(sqlink L){
	if (L == NULL) 
		return -1;
	free(L);
	L = NULL;
	return 0;
}
判断顺序表是否为空
/*
 * list_empty: Is list empty?
 * para L: list
 * @ret  1--empty   0--not empty
 * */
   int list_empty(sqlink L) {
   if (L->last == -1) 
   	return 1;
   else 
   	return 0;
   }
顺序表的长度
int list_length(sqlink L) {
	if (L == NULL) 
		return -1;
	return (L->last+1);
}
确定某个值的位置
int list_locate(sqlink L, data_t value) {
	int i ;
	for (i = 0; i <= L->last; i++) {
		if (L->data[i] == value) 
			return i;
	}
	return -1;
}
插入操作
int list_insert(sqlink L, data_t value, int pos) {
	int i;

//full
if (L->last == N-1) {
	printf("list is full\n");
	return -1;
}

//check para    0<=pos<=Last+1   [0, last+1]
if (pos < 0 || pos > L->last+1) {
	printf("Pos is invalid\n");
	return -1;
}

//move
for (i = L->last; i >= pos; i--) {
	L->data[i+1] = L->data[i];
}

//update value last
L->data[pos] = value;
L->last++;

return 0;
}
删除操作
int list_delete(sqlink L, int pos) {
	int i;

if (L->last == -1) {
	printf("list is empty\n");
	return -1;
}

//pos [0, last]
if (pos < 0 || pos > L->last) {
	printf("delete pos is invalid\n");
	return -1;
}

//move  [pos+1, last]
for (i = pos+1; i <= L->last; i++) {
	L->data[i-1] = L->data[i];
}

//update
L->last--;

return 0;
}
展示顺序表
int list_show(sqlink L) {
	int i;

if (L == NULL) 
	return -1;
if (L->last == -1)
	printf("list is empty\n");

for (i = 0; i <= L->last; i++) {
	printf("%d ", L->data[i]);
}
puts("");

return 0;
}
合并顺序表
int list_merge(sqlink L1, sqlink L2) {
	int i = 0;
	int ret;

while (i <= L2->last){
	ret = list_locate(L1, L2->data[i]);
	if (ret == -1) {
		if (list_insert(L1, L2->data[i], L1->last+1) == -1) 
			return -1;
	}
	i++;
}
return 0;
}

线性表链式存储（单链表）

链式存储结构的表示

  • 将线性表 L = ( a 0 , a 1 , … … , a n − 1 ) L=(a0,a1,……,an-1) L=(a0,a1,……,an−1)中各元素分布在存储器的不同存储块，称为结点，通过地址或指针建立元素之间的联系

image-20221017213737208

  • ​ 结点的data域存放数据元素ai，而next域是一个指针，指向ai的直接后继ai+1所在的结点。

image-20221017213744004

结点类型描述

   typedef  struct node
       
   {  
       data_t  data;  //结点的数据域//
       struct node *next; //结点的后继指针域//

   }listnode, *linklist;
可调用C语言中== m a l l o c ( ) malloc() malloc()函数==向系统申请结点的存储空间
      linklist p; 
      p = (linklist)malloc(sizeof(listnode));
    //创建一个类型为linklist的结点，且该结点的地址已存入指针变量p中：

单链表的优缺点

优点

  1. 是动态数据结构，可随时是链表分配和取消内存来增长或者缩短链表，不用给链表初始化大小
  2. 插入和删除操作简单，不必移动元素

缺点

  1. 遍历链表会比较麻烦，不能用索引的方式

链表的构建（C语言）

创建链表

linklist list_create() {
	linklist H;

    H = (linklist)malloc(sizeof(listnode));
    if (H == NULL) {
        printf("malloc failed\n");
        return H;
    }

    H->data = 0;
    H->next = NULL;

    return H;
}

链表尾部插入

int list_tail_insert(linklist H, data_t value) {
	linklist p;
	linklist q;

if (H == NULL) {
	printf("H is NULL\n");
	return -1;
}

//1 new node p
if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
	printf("malloc failed\n");
	return -1;
}
p->data = value;
p->next = NULL;

//2 locate tail node 
q = H;
while (q->next != NULL) {
	q = q->next;
}

//3 insert
q->next = p;

return 0;
}

获得链表第pos个节点

int list_tail_insert(linklist H, data_t value) {
	linklist p;
	linklist q;

if (H == NULL) {
	printf("H is NULL\n");
	return -1;
}

//1 new node p
if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
	printf("malloc failed\n");
	return -1;
}
p->data = value;
p->next = NULL;

//2 locate tail node 
q = H;
while (q->next != NULL) {
	q = q->next;
}

//3 insert
q->next = p;

return 0;

}

指定位置插入

int list_insert(linklist H, data_t value, int pos) {
	linklist p;
	linklist q;

if (H == NULL) {
	printf("H is NULL\n");
	return -1;
}

//1 locate node p (pos-1)
p = list_get(H, pos-1);
if (p == NULL) {
	return -1;
}

//2 new node q
if ((q = (linklist)malloc(sizeof(listnode))) == NULL) {
	printf("malloc failed\n");
	return -1;
}
q->data = value;
q->next = NULL;

//3 insert
q->next = p->next;
p->next = q;

return 0;
}

删除指定位置节点

int list_delete(linklist H, int pos) {
	linklist p;
	linklist q;

//1
if (H == NULL) {
	printf("H is NULL\n");
	return -1;
}

//2 locate prior
p = list_get(H, pos-1);
if (p == NULL) 
	return -1;
if (p->next == NULL) {
	printf("delete pos is invalid\n");
	return -1;
}

//3 update list
q = p->next;
p->next = q->next;//p->next = p->next->next;

//4 free
printf("free:%d\n", q->data);
free(q);
q = NULL;

return 0;
}

展示链表

int list_show(linklist H) {
	linklist p;

if (H == NULL) {
	printf("H is NULL\n");
	return -1;
}

p = H;

while (p->next != NULL) {
	printf("%d ", p->next->data);
	p = p->next;
}
puts("");

return 0;

}

删除链表

linklist list_free(linklist H) {
	linklist p;

if (H == NULL) 
	return NULL;

p = H;

printf("free:");
while (H != NULL) {
	p = H;
	printf("%d ", p->data);
	free(p);
	H = H->next;
}
puts("");

return NULL;

}

逆转链表

int list_reverse(linklist H) {
	linklist p;
	linklist q;

if (H == NULL) {
	printf("H is NULL\n");
	return -1;
}

if (H->next == NULL || H->next->next == NULL) {
	return 0;
}

p = H->next->next;
H->next->next = NULL;

while (p != NULL) {
	q = p;
	p = p->next;

​	q->next = H->next;
​	H->next = q;
}

return 0;

}

合并链表

int list_merge(linklist H1, linklist H2) {
	linklist p, q, r;

if (H1 == NULL || H2 == NULL) {
	printf("H1 || H2 is NULL\n");
	return -1;
}

p = H1->next;
q = H2->next;
r = H1;
H1->next = NULL;
H2->next = NULL;

while (p && q) {
	if (p->data <= q->data) {
		r->next = p;
		p = p->next;
		r = r->next;
		r->next = NULL;
	} else {
		r ->next = q;
		q = q->next;
		r = r->next;
		r->next = NULL;
	}
}

if (p == NULL) {
	r->next = q;
}else {
	r->next = p;
}

return 0;

}

xt;
​ H->next = q;
}

return 0;

}


### 合并链表

```c
int list_merge(linklist H1, linklist H2) {
	linklist p, q, r;

if (H1 == NULL || H2 == NULL) {
	printf("H1 || H2 is NULL\n");
	return -1;
}

p = H1->next;
q = H2->next;
r = H1;
H1->next = NULL;
H2->next = NULL;

while (p && q) {
	if (p->data <= q->data) {
		r->next = p;
		p = p->next;
		r = r->next;
		r->next = NULL;
	} else {
		r ->next = q;
		q = q->next;
		r = r->next;
		r->next = NULL;
	}
}

if (p == NULL) {
	r->next = q;
}else {
	r->next = p;
}

return 0;

}
深センのHZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线性表的讲解
创作不易，请多支持，将为本站提供更多「有价值的文章」。
07-06 986
线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linearlist）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。声明顺序表类型变量。.....
线性表简述，例题
weixin_62973176的博客
02-05 458
线性表，链表简述，循环链表例题
数据结构_二元组
热门推荐
hhhhhyyyyy8的博客
07-09 3万+
今天在牛客网上看到这样一个题目：当时做的时候直接没反应过来，后来看解析的时候，才知道，二元组，图论上学过嘛。而且，我们以前也经常接触，图(V,E)就是嘛。下面的解释转载自：https://www.cnblogs.com/larryzeal/p/5095522.html数据结构分为：逻辑结构、存储结构。逻辑结构分为：集合、线性结构、树形结构、图形结构。    --线性表、栈、队列、树、图等逻辑结构。...
4-逻辑结构的二元组表示方法
网络安全
05-25 1万+
1. 二元组表示法 对于数据的逻辑结构还有一种二元组表示法，下面是二元组表示方法。 逻辑结构二元组表示方法：B = （D , R） B——数据结构 D——数据元素的集合 R——D上二元关系的集合   在上面这种二元组表示方法中，B就是一种数据结构， 用上面的二元组来表示B这种数据结构时，就是由数据元素的集合D和D中的二元关系的集合R组成的，通过这句话，我们可以明白： D=di|1≤i...
数据结构知识整理4线性表——顺序表、链表、有序表
雨辰
02-15 3241
线性表 线性表是最简单也是最常用的一种数据结构。 逻辑结构 线性表定义：线性表是具有相同特性的数据元素的一个有限序列。该序列中所含元素的个数叫做线性表的长度，用n表示，n≥0。当n=0时，表示线性表是一个空表，表中不包含任何元素。设序列中第i（i表示逻辑序号）个元素为ai（1≤i≤n），则线性表的一般表示为：                                         ...
数据结构实验 顺序表和链表
10-08
顺序表和链表的基本实现 数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍...
数据结构Java线性表顺序表与链表小结PPT学习教案.pptx
10-05
数据结构Java线性表顺序表与链表小结PPT学习教案.pptx
C++语言实现线性表之链表实例
09-03
在C++编程中，线性表是一种常见的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。线性表的实现方式有多种，其中链表是常见的一种。链表不同于数组，它不连续存储元素，而是通过节点间的指针链接。本实例...
线性表和链表的基本算法
04-30
链表分为单向链表、双向链表和循环链表三种类型。单向链表的节点只能向前遍历，双向链表支持前后遍历，循环链表的最后一个节点指向第一个节点，形成一个环。 线性表与链表的主要操作包括插入、删除、查找等。在...
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
04-18
数组、链表、堆栈和队列、线性表和顺序表 数组、链表、堆栈和队列是最基本的数据结构，任何程序都会涉及到其中的一种或多种。数据结构是指数据之间的相互关系，即组织形式，有逻辑结构和物理结构之分。逻辑结构有...
（数据结构）二叉树的链式存储结构
weixin_51927215的博客
03-29 1万+
二叉树的顺序存储的缺点 因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或少会存在空间浪费的现象 图 1 普通二叉树的转化 如上图 1，普通二叉树里只有二个元素，最好的存储方式当然是开辟相对应的空间，但是顺序存储结构却让我们不能这么做！也就是说我们此时必须花更多的空间去存储相对少的元素 二叉树的链式存储 先慢慢介绍一下链式存储的节点结构！！！ 图 2 普通二叉树示意图 如上图 2 所示，若将其采用链式存储，则只需从树的根节点开始，将各个节点及其左右孩子使用链表存储 因
三元组，二元组，排列组合
阿文
12-11 2070
""" 算法题：二元组 Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and ...
稀疏矩阵 三元组顺序表（顺序解构）
KreamFan的博客
12-04 9579
稀疏矩阵      稀疏概念：当矩阵中只有很少的非零元素时，并且分布也不规律，非零元素只占20%~30%甚至更少，此矩阵称为稀疏矩阵       如果按照传统的存储方式例如数组存储会浪费大量空间（用于存储非零元素或者相同常数 ），但如果只存储少量的非零元素，而不存储大量的零或者相同常数，从而达到压缩存储的目的。但很多非零元素位置分布没有规律，所以需要添加一些辅助信息，例如行号
行逻辑链接的顺序表
SHUlpt的博客
03-13 1457
行逻辑链接的顺序表 使用三元组顺序表存储矩阵后，当需要提取矩阵某一行的非0元素时，需要遍历整个顺序表。 为了提高效率，可以在三元组的基础上，增加一个数组用于记录每一行第一个非0元素的存储位置（如果该行没有非0元素，记为-1） 注意：本类在实现时去掉了三元组中的行坐标，改为二元组，只记录了元素的纵坐标与值 二元组 每个二元组只记录非0元素的列号和元素值 #ifndef TWELEMNODE_H ...
二元组排序（动态规划）（C++）
mooncaptain的博客
10-03 2687
题目：给定一个N*2的二维数组，看作是一个个二元组，例如[ (a1,b1), (a2,b2), (a3,b3)],规定，如果想把二元数组甲放在二元数组乙上，甲中的a值必须大于乙中的a值，甲中的b值必须也得大于乙中的b值，问，给定一个二元数组，问可以罗成这样的数组几个？ 例：[ (5,4), (6,4), (6,7), (2,3)], 最多可以罗3个，如（2,3）-》（5,4）-》（6,7） 解
数据结构知识整理1基本知识及二元组
雨辰
02-15 3886
数据结构 数据结构讨论“描述现实世界实体的数学模型（通常为非数值计算）及其之上的运算在计算机上如何表示和实现”。 数据结构主要研究数据的各种组织形式及建立在这些组织形式之上的各种运算算法的实现（即数据组织和数据处理的方法）。 好的程序=合理的数据结构+好的算法（选择很大程度取决于描述实际问题所采用的数据结构） 数据：是描述客观事物的数和字符的集合。从计算机角度看，数据是所有能被输入到计算机...
数据结构--树和二叉树的一些知识点总结
最新发布
weixin_68489989的博客
07-09 432
数据结构--树和二叉树的一些知识点总结
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 661
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
Redis教程(二十三)：Redis的底层数据结构
十三月的博客
07-09 1487
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

深センのHZ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值