02——线性表

已于 2024-05-07 15:59:06 修改
阅读量299 收藏 2
点赞数 2
分类专栏： 王道数据结构代码部分 文章标签： 数据结构
于 2024-05-06 17:44:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50942741/article/details/138492365
版权

线性表

基本操作

Initlist(&L):初始化表
Length(L):求表长
LocateElem(L,e):按值查找操作
GetElem(L,i):按位查找操作
ListInsert(&L,i,e):插入操作
ListDelete(&L,i,&e):删除操作
PrintList(L):输出操作
Empty(L):判空操作
DestroyList(&L):销毁操作

顺序表

静态分配的顺序表存储结构

#define Maxsize 50
typedef struct{
	ElemType data[Maxsize];
	int length;
}SqList;

动态分配的顺序表存储结构

#define InitSize 100
typedef struct{
	ElemType *data;
	int Maxsize,length;
}SeqList;
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);或
L.data=new ElemType[InitSize]；

增加动态数组的长度 

#include <stdlib.h>
#define InitSize 10
typedef struct{
	int *data;
	int Maxsize,length;
}SeqList;

int main(){
	SeqList L;
	IniList(L);
	...
	IncreaseSize(L,5);
	return 0;
}

//初始化一个动态数组
void InitList(SeqList &L){
	L.data=(int*)malloc(InitSize*sizeof(int));
	L.length=0;
	L.MaxSize=InitSize;
}

//增加动态数组的长度
void IncreaseSize(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];//注意访问p指针指向的数组
	}
	L.MaxSize=L.MaxSize+len;
	free (p);
}

静态分配顺序表的初始化

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

动态分配顺序表的初始化

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

插入操作（位置在1～L.length+1之间）

bool ListInsert(SqList &L,int i,ElemType e){
     if(i<1||i>L.length+1)
	       return false;
     if(L.length>=MaxSize)//存储空间满
	       return false;
	 for(int j=L.length;j>=i;j--)
	       L.data[j]=L.data[j-1];//第i个元素后的元素后移
	 L.data[i-1]=e;
	 L.length++;
	 return true;
}

删除操作（位置在1～L.length之间）

bool ListDelete(SqList &L,int i,ElemType &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];//第i个元素后的元素前移
	 L.length--;
	 return true;
}

按值查找

int LocateElem(SqList L,ElemType e){
     int i;
	 for(i=0;i<L.length;i++)//若为i<InitSize，则初始化要全部初始化为0，防止脏数据影响
	        if(L.data[i]==e)  return i+1;//返回位序i+1
	 return 0;
}

按位查找（静态分配和动态分配一样）

ElemType GetElem(SqList L,int i){
     return L.data[i-1];
}
补充：结构体的比较不能直接用==，应该一个一个元素比较。

链表

单链表

单链表节点结构

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;


LNode *L;//表明这是一个指向单链表第一个结点的指针，强调结点
LinkList L;//同上，更强调链表

单链表的初始化及判空（带头结点）

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

单链表的初始化及判空（不带头结点）

bool InitList(LinkList &L){
	L=NULL;
	return true;
}

bool Empty(LinkList L){
	if(L==NULL) return true;
	else return false;
}
或者
bool Empty(LinkList L){
    return (L==NULL):
}

求表长操作（带头结点）

int length(LinkList L){
    int len=0;//计数变量
	LNode* p=L;
	while(p->next!=NULL){
	     p=p->next;
		 len++;
    }
	return len;
}

按序号查找

LNode* GetElem(LinkList L,int i){
     if(i<0) return NULL;
     LNode *p=L;
	 int j=0;//记录当前结点的位序，头结点为第0个结点，方便把结点插在第1个位置
	 while(p!=NULL&&j<i){
	       p=p->next;
		   j++;
	 }
	 return p;//返回指向第i个结点的指针或NULL
}

按值查找

LNode *LocateElem(LinkList L,ElemType e){
	LNode *p=L->next;
	while(p!=NULL&&p->data!=e){
		p=p->next;
	}
	return p;//找到则返回该结点指针，否则返回NULL
}

按位序插入（带头结点）

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1) return false;
	LNode *p=L;
	int j=0;//头结点是第0个结点
	while(p!=NULL&&j<i-1){//找到第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 ListInsert(LinkList &L,int i,ElemType e){
	if(i<1) return false;
	if(i==1){//仅第1一个结点与带头结点的操作不同
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s;
		return true;
	}
	
	LNode *p=L;
	int j=1;//没有头结点了
	while(p!=NULL&&j<i-1){//找到第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,ElemType e){//在p结点之后插入元素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 InsertPriorNode(LNode *p,ElemType 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;
}

按位序删除（带头结点）

bool ListDelete(LinkList &L,int i,ElemType &e){
	if(i<1) return false;
	LNode *p=L;
	int j=0;
	while(p!=NULL&&j<i-1){//找到第i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL) return false;
	if(p->next==NULL) return false;
	LNode *q=p->next;
	e=q->data;
	p->next=q->next;
	free(q);
	return true;
}

指定结点的删除

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;
}
//如果p是最后一个结点，只能从表头开始寻找p的前驱

头插法建立单链表

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

尾插法建立单链表 

LinkList List_TailInsert(LinkList &L){
	int x;
	L=(LNode*)malloc(sizeof(LNode));
	LNode *s,*r=L;//尾插法需要尾指针
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;
		scanf("%d",&x);
	}
	r->next=NULL;
	return 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=NULL;
	L->next=NULL;
	return true;
}

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

双链表的插入

bool InsertNextDNode(DNode *p,DNode *s){//将s插在p之后
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;
	p->next=s;
}

//如果p是最后一个结点，则代码需要修改
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; //p有后继结点
	s->prior=p;
	p->next=s;
	return true;
}

 双链表的删除

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;//q不是最后一个结点
	free(q);
	return true;
}

双链表的销毁

void DestoryList(DLinkList &L){
	while(L->next!=NULL) DeleteNextDNode(L);//依次释放结点
	free(L);
	L=NULL;
}

双链表的遍历

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

//前向遍历
while(p!=NULL) p=p->prior;

//前向遍历（跳过头结点）
while(p->prior!=NULL) p=p->prior;

循环单链表

循环单链表的初始化

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

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

//判断是否是循环双链表的表尾结点
bool isTail(DLinkList L,DNode *p){
	if(p->next==L) return true;
	else return false;
}

循环双链表的插入

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

循环双链表的删除

//删除p的后继结点q
p->next=q->next;
q->next->prior=p;
free(q);

静态链表

静态链表结点结构

#define MaxSize 10
struct Node{
	ElemType data;
	int next;//下一个元素的数组下标
};

用代码定义一个静态链表

#define MaxSize 10
struct Node{
	ElemType data;
	int next;//下一个元素的数组下标
};

typedef struct Node SLinkList[MaxSize];
struct Node a[MaxSize];//用SLinkList定义一个长为MaxSize的Node型数组
#define MaxSize 10
typedef struct{
	ElemType data;
	int next;//下一个元素的数组下标
}SLinkList[MaxSize];

SLinkList a;

world-wide-wait
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习day02——线性表
jjw_lyf的博客
10-08 661
文章目录一、线性表的（类型）定义和特点二、类C语言有关操作补充说明1.元素类型说明2.数组定义3.C语言的内存动态分配4.C++的动态内存分配5.C++中的参数传递三、线性表的顺序表示和实现1.顺序存储结构2.顺序表基本操作的实现 一、线性表的（类型）定义和特点 线性表是具有相同特性的数据元素的一个有限序列。 逻辑特征： 有且经有一个开始节点，仅有一个直接后继； 有且经有一个结束节点，仅有一个直接前驱； 其余的内部节点都有且经有一个直接前驱和一个直接后继。 抽象数据类型线性表的定义： AD
数据结构——线性表
02-06
该文件包括各种线性表的头文件，另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的...
数据结构02——线性表的顺序表小结
weixin_45658431的博客
09-18 54
2）在访问线性表时，可以通过公式快速的计算出任何一个数据元素的存储地址。因此可以粗略的认为：访问每个元素所花的时间相等。1）利用数据元素的存储位置表示线性表中相邻元素之间的前后关系，即线性表的逻辑结构与存储结构一致。属于静态存储形式，数据元素的个数不能自由扩充。注：这种存取元素的方法被称为随机存取法。在插入、删除某一元素时，需要移动大量元素。存储密度大（结点本身所占存储量。空间复杂度：S(n)=O(1)可以随机存取表中任一元素。结点结构所占存储量）时间复杂度：O(n)
【数据结构与算法】Part02——线性表(C++)
四口鲸鱼爱吃盐的博客
10-18 3782
线性表：顺序表；链式表：单链表，循环链表，双向循环链表；线性表的应用；案例分析与实现；顺序表和链式表的比较
数据结构——线性表—— 2016_10_13
热门推荐
XHS_12302 的博客
10-13 1198万+
自己做的，只有插入和删除，不过基本原理就这样
线性表学习02——线性表的顺序表示和实现
2301_80034711的博客
04-14 1065
P(n)(x)=p1x的e1次方+p2x的e2次方+...+p(m)x的e(m)次方：线性表P=((p1,e1),(p2,e2),...,(pm,em))//多项式可能达到的最大长度//多项式非零项的定义float p；//系数int e；//指数//存储空间的基地址int length；//多项式中当前项的个数｝SqList；//多项式的顺序存储结构类型为SqList实例② 图书表的顺序存储结构类型定义//图书表可能达到的最大长度//图书信息定义//图书ISBN。
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
数据结构——线性表类模板
12-19
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在C++编程语言中，类模板被广泛用于实现抽象数据类型，它允许我们创建通用的数据结构，适用于多种数据类型。本主题将...
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
数据结构--二叉树和堆
binhyun的博客
07-07 838
1.基本概念 2.树的遍历方法 3.满二叉树&&完全二叉树 4.逻辑结构&&物理结构 5.推理公式 6.二叉树应用--堆 7.简单实现堆
数据结构第14节 加权图
hummhumm的专栏
07-07 1321
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 1150
插入排序&&希尔排序 实现原理
D1.排序
2302_79232710的博客
07-07 203
快速排序和归并排序
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 2175
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
数据结构之链表
2301_80772499的博客
07-07 537
链表的结构，是否带头，是否循环，是否双向六中结构讲解，以及链表的用途,缺点
【排序 - 堆排序】
最新发布
2302_80393814的博客
07-10 356
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
数据结构--单链表实现
LH__1314的博客
07-05 1429
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
【力扣】每日一题—第217题，存在重复元素
m0_65146517的博客
07-05 329
暴力求解两重for循环直接出结果，但是超时了！如果数组中每个元素互不相同，返回。如果任一值在数组中出现。感觉自己越来越厉害了，哎，不过如此，嘿嘿嘿。
U201614532 吕鹏泽2
08-08
这篇文档是吕鹏泽同学的一份数据结构实验报告，主要探讨了基于不同存储结构的线性表、二叉树以及图的实现。以下是各部分的详细知识点： 1. 基于顺序存储结构的线性表实现 - 问题描述：使用动态分配的顺序表来实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值