数据结构详细笔记——线性表

最新推荐文章于 2024-06-07 16:00:07 发布
最新推荐文章于 2024-06-07 16:00:07 发布
阅读量353 收藏 4
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 笔记 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44732078/article/details/133762747
版权

文章目录

线性表的三要素

逻辑结构（定义）

线性表是具有相同数据类型的n（n>=0）个数据元素的有限 序列，其中n为表长，当n=0时线性表是一个空表。

若用L命名线性表，则一般表示为 L= (a1,a2,…,ai,ai+1,…an)

总结一下：线性表的逻辑结构只需要掌握以下几点：
1、数据元素同类型、有限、有序
2、表长为0则是一个空表
3、数据元素的位序（从1开始），数组的位序（从0开始）

数据的运算（基本操作）

InitList(&L)
初始化表：构造一个空的线性表L，分配内存空间

DestroyList(&L)
销毁操作：销毁线性表，并释放线性表L所占用的内存空间

ListInsert(&L,i,e)
插入操作：在表L中的第i个位置上插入指定元素e

ListDelete(&L,i,&e)
删除操作：删除表L中的第i个位置的元素，并用e返回删除元素的值

LocateElem(L,e)
按值查找：在表L中查找具有给定关键字值的元素

GetElem(L,i)
按位查找：获取表L中第i个位置的元素的值

存储结构（物理结构）

顺序表（顺序存储）

顺序表的定义

顺序表——用顺序存储的方式实现线性表，把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中

顺序表的实现——静态分配

#define MaxSize 10
typedef stuct{
	int data[MaxSize];
	int length;
}SqList;

初始化静态分配顺序表

void InitList(SqList &L){
	for(int i=0; i < MaxSize; i++){
		L.data[i] = 0;
	}
	L.length = 0;
}

顺序表的实现——动态分配

#define InitSize 10
typedef struct{
	int *data;
	int MaxSize;
	int length;
}SeqList;

初始化动态分配顺序表

void InitList(SeqList &L){
	L.data = (int *) malloc(InitSize * (sizeof(int));
	L.Maxzise = InitSize;
	L.length = 0;
}

增加动态数组的长度

void IncreseSize(SeqList &L, int len){
	int *p = L.data;
	L.data = (int *) malloc((L.Maxsize + len) * sizeof(int));
	for(int i = 0; i< L.length; i++){
		L.data[i] = p[i];    // 将数据复制到新的区域
	}
	L.Maxsize = L.Maxsize + len;
    free(p);
 }
顺序表的特点

1、随机访问，即可以在O(1)时间内找到第i个元素。
2、存储密度高，每个节点只存储数据元素。
3、拓展容量不方便（即便采用动态分配方式实现，拓展长度的时间复杂度也比较高）。
4、插入、删除操作不方便，需要移动大量的元素。

顺序表的基本操作

插入操作—— 时间复杂度 O(n)

#define MaxSize 10
typedef struct{
	int data[MaxSize];
	int length;
}SqList;

void InitList(SqList &L){
	for(int i = 0; i < MaxSize; i++){
		L.data[i] = 0;
	}
	L.length = 0;
}

bool ListInsert(SqList &L, int i, int e){
	if(i < 1 || i > L.length+1 )   // 判断i是否有效
		return false;
	if(L.length >= MaxSize)        // 当前存储空间已满，不能插入
		return false;
	for(int j = L.length; j>=i; j--){  // 将第i个元素及之后的元素后移
		L.data[j] = L.data[j-1];
	}
	L.data[i-1] = e;    // 在位置i处放入e
	L.length ++;        // 长度加1
	return true;
}

int main(){
	SqList L;
	InitList(L);
	ListInsert(L,3,9);
}

删除操作 —— 时间复杂度 O(n)

bool ListDelete(SqList &L, int i, &e){
	if(i < 1 || i > L.length)
		return false;
	e = L.data[i-1];
	for(int j = i; j < L.length; j++){
		L.data[j-1] = L.data[j];
	}
	L.length --;
	return true;
}
int main(){
	SqList L;
	InitList(L);
	...
	int e = -1;
	ListDelete(L,3,e);
}

按位查找 —— 时间复杂度 O(1)

int GetElem(SqList L, int i){
	return L.data[i-1];
}

按值查找 —— 时间复杂度 O(n)

int LocateElem(SqList L, int e){
	for(let i = 0; i < L.length; i++){
		if(L.data[i] == e){
			return i+1;   // 返回的是位序，需要加一
		}
	}
	return 0;
}

链表（链式存储）

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

不带头结点的单链表

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

// 初始化一个空的单链表
bool initList(LinkList &L){
	L = NULL;  // 空表，暂时还没有任何结点
	return true;
}

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

void mian(){
	LinkList L;
	InitList(L);
}

带头结点的单链表

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;
}

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

void mian(){
	LinkList L;
	InitList(L);
}

值得注意的点是：
LinkList 等价于 LNode *
LinkList 强调的是链表
LNode * 强调的是结点

单链表的基本操作

按位序插入（带头结点） —— 时间复杂度 O(n)

bool ListInsert(LinkList &L, int i, int e){
	if(i < 1)
		return false;
	LNode *p;  // 指针p指向当前扫描到的结点
	int j = 0;  // 当前p指向的是第几个结点
	p = L; // L指向头结点
	while(p != NULL && j < i-1){
		p = p->next;
		j++;
	}
	if(p == NUll)
		return false;
	LNode *s = (LNode *) malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

按位序插入（不带头结点） —— 时间复杂度 O(n)

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;
		s = L;
		return true;
	}
	LNode *p;  // 指针p指向当前扫描到的结点
	int j = 0;  // 当前p指向的是第几个结点
	p = L; // L指向头结点
	while(p != NULL && j < i-1){
		p = p->next;
		j++;
	}
	if(p == NUll)
		return false;
	LNode *s = (LNode *) malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

以上代码都有一段重复逻辑：在指定结点的后插操作，因此可以将重复逻辑封装起来
指定结点的后插操作 —— 时间复杂度 O(1)

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;
}

指定结点的前插操作—— 时间复杂度 O(1)

bool InsertNextNode(LNode *p, int e){
	if(p == NUll)
		return false;
	LNode *s = (LNode *) malloc(sizeof(LNode));
	if(s == NULL)
	    return false;
	s->next = p->next；
	p->next = s;
	s->data = p->data;  // 同样是后插操作，改变数据的位置，完美实现前插操作
	p->data = e;
	return true;
}

按位序删除（带头结点） —— 时间复杂度 O(n)

bool ListInsert(LinkList &L, int i, int e){
	if(i < 1)
		return false;
	LNode *p;  // 指针p指向当前扫描到的结点
	int j = 0;  // 当前p指向的是第几个结点
	p = L; // L指向头结点
	while(p != NULL && j < i-1){
		p = p->next;
		j++;
	}
	if(p == NUll)
		return false;
	if(p->next == NULL)
		return false; 
	LNode *q = p->next;  // 令q指向被删除结点
	e = q->data;
	p->next = q->next;
	free(q); 
	return true;
}

按位序查找（带头结点） —— 时间复杂度 O(n)

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

按值查找（带头结点） —— 时间复杂度 O(n)

LNode * LocateElem(LinkList L, int e){
	LNode *p = L->next; // 从第一个结点开始寻找
	while(p != NULL && p->data != e){
		p = p->next;
	}
	return p;
}
尾插法建立单链表
LinkList List_TailInsert(LinkList &L){
	int x;
	L = (LNode *) malloc(sizeof(LNode));  // 建立头结点
	LNode *s,*r=L;  // r为表尾指针
	scanf("%d",&x);
	while(x!=9999){  // 表示结束
		s = (LNode *) malloc(sizeof(LNode));
		s=>data = x;
		r->next = s;
		r = s;    // r指向新的表尾结点
		scanf("%d",&x);
	}
	r->next = NULL;
	return L;
}
头插法建立单链表
LinkList List_HeadInsert(LinkList &L){
    LNode *s;
	int x;
	L = (LNode *) malloc(sizeof(LNode));  // 建立头结点
	L->next = NULL;
	scanf("%d",&x);
	while(x!=9999){  // 表示结束
		s = (LNode *) malloc(sizeof(LNode));
		s=>data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d",&x);
	}
	return L;
}
双链表
双链表的定义
typedef struct DNode{
	int data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

双链表的初始化（带头结点）

bool InitDLinkList(DLinkList &L){
	L = (DNode *) malloc(sizeof(DNode));
	if(L == NULL)
		return false;
	L->prior = NULL;   // 头结点的 prior 永远指向null
	L->next = NULL;
	return true;
}

双链表的插入

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

双链表的删除

// 删除p结点的后继结点
bool DeleteNextDNode(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 DestroyList(DLinkList &L){
	while(L->next != NULL){
		DeleteNextDNode(L);
	}
	free(L);
	L = NULL;
}

双链表的遍历 —— 时间复杂度 O(n)

// 后向遍历
while(p != NULL)
	p = p->next;

//前向遍历
while(p != NULL)
	p = p->prior;
	
//前向遍历(跳过头结点)
while(p->prior != NULL)
	p = p->prior;
循环链表
循环单链表

初始化循环单链表

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

bool InitList(LinkList &L){
	L = (LNode *) malloc(sizeof(LNode));
	if(L == NULL)
		retun false;
	L->next = L;   // 头结点的next指向头结点
	return true;
}

判断循环单链表是否为空

bool Empty(LinkList L){
	if(L->next == L)
		return true;
	else
		return false;
}

判断结点p是否为循环单链表的表尾结点

bool isTail(LinkList L, LNode *p){
	if(p->next == L)
		return true;
	else
		return false;
}
循环双链表

初始化循环单链表

typedef struct DNode{
	int 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 Empty(DLinkList L){
	if(L->next == L)
		return true;
	else
		return false;
}

判断结点p是否为循环双链表的表尾结点

bool isTail(DLinkList L, LNode *p){
	if(p->next == L)
		return true;
	else
		return false;
}

判断结点p是否为循环双链表的表尾结点

bool isTail(DLinkList L, LNode *p){
	if(p->next == L)
		return true;
	else
		return false;
}

双链表的插入

// 在p结点之后插入s结点
bool InsertNextDNode(DNode *p, DNode *s){
	s->next = p->next;
	p->next->prior = s;
	s->prior = p;
	p->next = s;
}
静态链表

静态链表：分配一整片连续的内存空间，各个结点集中安置

定义静态链表

#define MaxSize 10
typedef struct{
	ElemType data;   // 存储数据元素
	int next;        // 下一个元素的数组下标
}SLinkList[MaxSize];

优点：增、删操作不需要大量移动元素
缺点：不能随机存取，只能从头结点开始依次往后查找，容量固定不变

顺序表与链表的区别

1、逻辑结构
都是属于线性表，都是线性结构

2、存储结构

顺序表：
优点：支持随机存取，存储密度高
缺点：大片连续空间分配不方便，改变容量不方便

链式表
优点：离散的小的空间分配方便，改变容量方便
缺点：不可以随机存取，存储密度低

用顺序表 or 链表？
表长难以预估、经常要增加、删除元素————链表
表长可预估，查询（搜索）操作比较多————顺序表

哎哟喂_!
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验——线性表子系统
07-31
用结构体描述一个字符型的单链表；创建线性表；在线性表中插入元素、删除元素、显示线性表中所有元素。
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构学习笔记——线性表逻辑结构和顺序存储结构
weixin_62440328的博客
10-26 2113
用顺序存储方法存储的线性表。所谓顺序存储方法存储的线性表就是把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。
数据结构笔记——线性表
Robod的博客
03-27 2953
数据结构笔记——线性表
数据结构笔记二——线性表
weixin_64908198的博客
04-12 1245
线性表
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 39万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构学习笔记——线性表
qq_45212020的博客
03-17 250
线性表的顺序表示（顺序表） 特点： 1.随机访问：即可以在O(1)时间内找到第i个元素 2.存储密度高，每个节点只存储数据元素 3.扩展容量不方便（即使采用动态分配，扩展长度的时间复杂度也比较高） 4.插入、删除操作不方便，需要移动大量元素 顺序表的静态分配 #define MAXsize 100 //静态顺序表的最大容量 typedef struct//静态顺序表结构 { int data[MAXsize]; int length; }Sqlist; 静态顺序表初始化 void Static_Ini
数据结构笔记1——线性表
cyt_6328的博客
09-28 645
数据结构笔记1——线性表以及顺序表。 内含顺序表基本操作以及上机题目，如有错误欢迎指正！
数据结构学习笔记——线性表之顺序表
HiSi_的博客
09-02 1488
线性表的定义： 具有相同性质元素的一个有限序列。 序列中所含元素个数为线性表的长度。 线性表中每个元素由逻辑序号唯一确定，逻辑序号是由1开始的，而物理序号（我们说的数组的下标是从0开始的）。 序列中的第一元素叫做表头元素，最后一个元素叫做表尾元素。 线性表的抽象数据类型描述： ADT List { 数据对象： D = {ai | 1<=i<=n, ai为ElemType对象} //ElemType是自定义类型的标识符， //在后面的讨论中，ai是结构体类型的。 数据关系： R =
数据结构笔记Lite——线性表
Fred_Bohr_Locke的博客
09-26 111
存储地址计算 s=sizeof(datatype) 一维数组 &a[i]=&a[0]+i*s 二维数组（行优先） k=i*t2+j 二维数组（列优先） k=j*t1+i 三维数组 l=i*t2*t3+j*t1+k 下三角矩阵 k=i(i+1)2\frac{i(i+1)}{2}2i(i+1)​+j 上三角矩阵 k=i(2n−i+1)2\frac{i(2n-i+1)}{2}2i(2n−i+1)​+j-i 对称矩阵（存储下三角） k= ...
数据结构实验报告——线性表.pdf
11-12
。。。
数据结构实验报告——线性表.docx
11-12
。。。
北邮数据结构实验报告——线性表.pdf
11-10
。。。
12- Redis 中的 链表 数据结构
YoungSoulwt的博客
06-04 576
Redis 中的 链表 数据结构
【数据结构】二叉搜索树--BST，Binary Search Tree
Z1tai的博客
06-04 751
二叉搜索树是一种重要且常用的数据结构，其节点具有左子树和右子树，且左子树所有节点值小于根节点，右子树所有节点值大于根节点，这种特性使得查找、插入和删除操作非常高效。然而，如果树结构不平衡，会导致性能下降。因此，对于实现二叉搜索树的算法和数据结构有深入了解是至关重要的，同时也需要了解其他优化的数据结构如AVL树、红黑树等。
数据结构（树）
最新发布
lazy_girl_666的博客
06-07 489
原先的左子节点变成新的父节点，并把多余的右子节点出让，给已经降级的根节点当左子节点。原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右节点。如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点（Nil）是黑色的；步骤： 1） 把不平衡的点作为支点，把支点左旋降级，变成左子结点，晋升原来的右子节点。对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。当根节点左子树的左子树有节点插入，导致二叉树不平衡。
Redis的数据结构以及对应的使用场景
AKANGYONG的博客
06-04 396
综上所述，可以看到Redis提供的多种数据结构及其使用场景是非常广泛且灵活的。每种数据结构都有其特定的用途和优势，在实际应用中应根据具体需求来选用合适的数据结构，以最大化Redis的性能和效率。在实际应用中，选择合适的数据结构对于提高系统性能和简化开发至关重要。例如，若需要快速查询和更新操作，则哈希可能是一个更好的选择；而对于无需重复元素的排行榜功能，有序集合提供了现成支持。这些数据结构在应用开发中扮演着重要的角色，它们各自适用于不同的使用场景和需求。Redis支持的数据结构包括。
【数据结构】各类排序算法 时间复杂度、空间复杂度、稳定性的比较
m0_61628700的博客
06-05 653
排序算法大全（快速、堆、归并、插入、折半、希尔、冒泡、计数、基数）各算法比较
数据结构中的线性表笔记
08-20
- *2* [数据结构笔记——线性表](https://blog.csdn.net/weixin_43461520/article/details/123783563)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值