线性表(数据结构)

已于 2024-08-05 13:43:55 修改
阅读量194 收藏 2
点赞数 8
文章标签： 算法 c语言
于 2024-08-05 13:41:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81236551/article/details/140908614
版权

 线性表是一种基本的数据类型，每一个元素对应了相应的位置，线性表分为顺序结构和链式结构，也就是顺序表和链表。凡是谈到线性表的实现就要实现基本的“增 删 查 改”。

顺序表

顺序表是一种将数据顺序且连续存放的结构，这核心实则一种数组形式，但是顺序表的内存是动态分配的而数组的元素是静态分配。顺序表由结构体定义，结构体中存在三个变量，分别为：指针变量（用于生成顺序表）、size（用于记录有效元素个数）、capacity（用于记录数组有效元素空间）。顺序表既然是一种数组，那么他的访问（通过下标）和空间释放是更加方便的。

typedef int SLdatetype;
typedef  struct Seqlist  //typedef struct Seqlist SL;
{
	SLdatetype* arr;
	int size;//有效数位
	int capacity;//有效空间容量
}SL;

//C语言中传值传参的话，就不会对节点产生影响，这里就需要传节点参数
void initialize(SL* ps);//初始化顺序表
void destroyed(SL* ps);//顺序表销毁

void headpush(SLdatetype*p,SLdatetype x);//头插
void endpush(SLdatetype* p, SLdatetype x);//尾插


void headdel(SLdatetype* p);//头删
void enddel(SLdatetype* p);//尾删
void print(SL* ps);//打印数组

void posdel(SL* ps, int n);//指定位置删除
void pospush(SL* ps, unsigned int n, SLdatetype x);//指定位置插入元素


void initialize(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity=0;

}
void destroyed(SL* ps)
{
	if (ps->arr != NULL)//空值不用多余释放元素
	{
		free(ps->arr);
		ps->arr = NULL;
	}
	ps->size = 0;
	ps->capacity=0;
}


void headpush(SL* ps, SLdatetype x)
{
		assert(ps->arr);
		assert(ps->capacity);
		if (ps->size == ps->capacity)
		{
			int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
  			SLdatetype* new = (SLdatetype*)realloc(ps->arr, newcapacity * sizeof(SLdatetype));
			if (new != NULL)
			{
				ps->capacity = newcapacity;
				ps->arr = new;
			}
			else
				return;
		}
		for (int i = ps->size; i>=0 ; i--)
		{
			ps->arr[i+1] = ps -> arr[i ];
		}
		ps->arr[0] = x;
		ps->size++;
}
    

void endpush(SL* ps, SLdatetype x)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		 SLdatetype* new = (SLdatetype*)realloc(ps->arr, newcapacity * sizeof(SLdatetype));
		if (new != NULL)
		{
			ps->capacity = newcapacity;
			ps->arr = new;
		}
		else
			return;
	}
	ps->arr[ps->size++] = x;
}


void headdel(SL* ps)
{
	assert(ps->size);
	for (int i =0; i<ps->size ; i++)
	{
		ps->arr[i] = ps->arr[i+1];
	}
	ps->size--;
}


void enddel(SL* ps)
{
	assert(ps->size);
	ps->arr[ps->size-1];
	ps->size--;

}

void posdel(SL*ps,unsigned int n)
{
	assert(n<ps->size);
	assert(ps->size);
	for (int i=n-1;i<ps->size-1;i++)
	{
		ps->arr[i] = ps->arr[i+1];
	}
	ps->size--;
}



void pospush(SL* ps, unsigned int n,SLdatetype x)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLdatetype* new = (SLdatetype*)realloc(ps->arr, newcapacity * sizeof(SLdatetype));
		if (new != NULL)
		{
			ps->capacity = newcapacity;
			ps->arr = new;
		}
		else
			return;
	}
	for (int i = ps->size; i >=n; i--)
	{
		ps->arr[i] = ps->arr[i-1];
	}
	ps->arr[n - 1] = x;
	ps->size++;
}

void print(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

这里是测试

#include "seqlist.h"
 int main()
{
	 SLdatetype a = 6;
	 SL s;
	 initialize(&s);//初始化顺序表
	 endpush(&s, 1);//尾部加入
	 endpush(&s, 2);
	 endpush(&s, 3);
	 endpush(&s, 4);
	headpush(&s,6);//头部加入
	print(&s);//打印顺序表
	headdel(&s);//头部删除
	print(&s);
	enddel(&s);//尾部删除
	print(&s);
	pospush(&s, 2, 7);//指定位置加入
	print(&s);
	posdel(&s,2);//指定位置删除
	print(&s);
	 return 0;
}

链表

 链式结构即将各个结构体节点由自身的结构体指针链接起来，形成类似链条结构，各个节点使用自身结构体指针访问下个节点，访问方式相对于顺序表就不太方便了，链表的各个节点在内存上是不连续的，也就是说最后释放节点的时候就不能直接像顺序表一样直接用free函数释放。

typedef int datetype;
typedef struct linklist
{
	datetype head;
	struct linklist* next;
}link;

void endpush(link** s, datetype x);
void print(link* pre);
void headpush(link** s, datetype x);
void enddel(link**s);
link* Find(link** s, datetype x);
void ptdel(link** s, datetype x);//指定节点删除
void ptpush(link** s, link* p, datetype x);
void ptbpush(link* p, datetype x);//再指定位置之后插入数据
void ptdel(link** s, link* p);//指定节点删除
void pbdel(link** s, link* p);//删除指定节点之后的节点
void destroy(link** s);//销毁链表
void headdel(link** s);

link* ornode(datetype x)//初始化
{
	link* new = (link*)malloc(sizeof(link));
	assert(new);
  	new->head = x;
	new->next=NULL;
	return new;
}



void endpush(link** s, datetype x)//尾插
{
	assert(s);
	link* s1 = *s;
	link* new1 = ornode(x);
	if (s1 == NULL)
	{
		*s= ornode(x);
	}
	else
	{
	
		while (s1->next)
		{
		 s1 = s1->next;
		}
	
	s1->next = new1;
	}
}


void print(link* pre)//打印
{
	link* ret = pre;
	while ( ret)
	{
		printf("%d->",ret->head);
		ret = ret->next;
	}
	printf("NULL\n");
}

void headpush(link** s, datetype x)//头插
{

	link* new = (link*)malloc(sizeof(link));
	new=ornode(x);
	new->next = *s;
}


void enddel(link** s)//尾删
{
	assert(s && *s);
	link* s1 = *s;
	link* s2=s1;
	while (s1->next)
	{
		s2 = s1;
		s1 = s1->next;
	}
	free(s1);
	s1 = NULL;
	s2->next= NULL; 
}


void headdel(link** s)//头删
{
	assert(s && *s);
	link* next = (*s)->next;
	free(*s);
	*s = next;
}
//使用一个新指针指向第一个节点的next值，再释放第一个节点后，再将新指针的值赋给释放过后的头结点，以导致删除头结点




link* Find(link** s, datetype x)
{
	link* point = *s;
	while (point)
	{
		
		if (point->head == x)
			return point;
		point = point->next;
	}
	return NULL;
}
//根据head值查找，创建指向头指针的新指针，在进行遍历查找



void ptpush(link** s, link* p,datetype x)//再指定位置之前插入数据
{
	assert(s && *s);//s不能为NULL，s指向的地址也不能为空
	assert(p);
	link* new = ornode(x);//这是要插入的节点
	link* pr = *s;
  	while (pr->next != p)//结果是p的前面的一个节点，不是用pr!=p否则结果会是pr==p
	{
		pr = pr->next;
	}
	pr->next = new;
	new->next = p;
}


void ptbpush(link* p, datetype x)//再指定位置之后插入数据
{
	assert(p);
	link* new = ornode(x);
	new->next = p->next;
	p->next = new;
	//
	//相同写法
	/*p->next = new;
	new->next = p->next;*/
}


void ptdel(link** s, link* p)//指定节点删除
{
	assert(p);
	assert(*s&&s);
	if (p == *s)//如果指定节点是第一个节点
	{
		link* next = (*s)->next;//定义一个新指针

		free(*s);
		*s = next;
	}
	else{
	link* pr = *s;
	link* p1 = p;
	while (pr->next!=p)
	{
		pr = pr->next;
	}
	pr->next = p1->next;
	free(p);
	p = NULL;
	} 
}

void pbdel(link** s, link* p)//删除指定节点之后 
{
	assert(s && *s);
	assert(p);
	link* pnext = p->next;//p的下个节点
	link* pr = (p->next)->next;//p的下下个节点
	p->next= pr;
	free(pnext);
	pnext = NULL;

}
void destroy(link**s)//销毁链表
{

	link* p = *s;
	while (*s)
	{
		p = (*s)->next;
		free(*s);
		*s = p;
	}//需要定义新变量记录该节点的下一个节点，释放该节点后再将新变量的值赋给该节点，以此循环

}

 链表测试用例

int main()
{
	link* node1= (link*)malloc(sizeof(link));
	node1->head = 1;
	link* node2 = (link*)malloc(sizeof(link));
	node2->head = 2;
	link* node3 = (link*)malloc(sizeof(link));
	node3->head = 3;
	link* node4 = (link*)malloc(sizeof(link));
	node4->head = 4;
    //这里也可以先创建单个节点，然后用尾插方式创建
	
	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;
	headpush(&node1, 6);
	print(node1);
	endpush(&node1, 1);
	print(node1);
	enddel(&node1);
	print(node1);
	headdel(&node1);
	print(node1);
	//
	//
	//
	//
	link*p=Find(&node1,3);
	printf("Find(&node1,3)->head是%d\n",p->head);
	ptpush(&node1, p,3);
	print(node1);
	ptbpush(p, 4);
	print(node1);
	ptdel(&node1,p);
	print(node1);
	ptdel(&node1, node1);
	print(node1);
	pbdel(&node1, Find(&node1, 3));
	print(node1);
	destroy(&node1);
	print(node1);
	return 0;
}

链表因为不能像顺序表一样从下标直接访问，就只能整个链表一个一个接着遍历查找，甚至不能直接访问前面一个节点，这样链表的操作就变得很限制了。但相反链表使数据存储变的更加灵活。

同时链表存在双向链表，即将链表尾节点的指针指向第一个节点，整个链式结构就形成了一个环。增删查改的方式就会变得更方便一点，这里就不多说了。

学以上就是我对线性表的一些学习，欢迎指正讨论。

敲码brain
关注
第2章 线性表 数据结构PPT
09-18
线性表是一种基础且重要的数据结构，它由n（n≥0）个类型相同的数据元素组成，这些元素按照特定的顺序排列，形成一个有限序列。线性表的特点在于其元素之间存在一对一的关系，即除了第一个元素没有直接前驱，最后一...
一文带你搞懂什么是链表
henghengzhao_的博客
10-24 679
如果我们在中间进行插入或者删除，那么插入或者删除的位置之后的元素的地址都需要改变（因为物理地址是连续的）。代码实现是对链表整体上的一个实现，中间包含了链表的初始化，销毁链表，清空链表，返回链表长度，指定元素的位置，指定位置的元素，求某元素的前驱和后继等等操作。也就是说元素在计算机内"物理地址"上是相邻的，我们只需要知道第一个元素的地址，线性表上的任意一个元素都可以。概念：是一组任意的存储单元存储线性表上的数据元素（这组存储单元可以是连续的，也可以是不连续的），用来存储直接后继存储位置的域称为。
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
线性表与链表
weixin_52744725的博客
08-08 1476
1、线性结构在数据元素的非空有限集中：存在唯一的一个被称做“第一个”的数据元素存在唯一的一个被称做“最后一个”的数据元素除第一个之外，集合中的每个数据元素均只有一个前驱除最后一个之外，集合中的每个数据元素均只有一个后继2、线性表线性表是n个数据元素的有限序列，同一线性表中的元素必定具有相同特性，相阾的数据元素之间存在着序偶关系。线性表中元素的个数n(n>=0)定义为线性表的长度，0==n时称为空表，在非空表中每个数据元素都有一个确定的位置(下标)。...
线性表，线性表和链表的区别
weixin_30588729的博客
09-21 2340
存储类别 顺序存储结构单链表 存储分配方式 用一段连续的存储单元依次存储线性表的数据元素 采用链式存储结构，用一组任意的存储单元存放线性表的元素 时间性能 查找O（1）、插入和删除O（n） 查找O（n）、插入和删除O（1） 空间性能 需要预分配存储空间，分大了浪费，小了容易发生上溢 不需要分配存储空间，只要有就可以分配，元素个数不受限制...
线性表和链表的区别
pengyingt的博客
07-28 2万+
存储类别 顺序存储结构 单链表 存储分配方式 用一段连续的存储单元依次存储线性表的数据元素 采用链式存储结构，用一组任意的存储单元存放线性表的元素 时间性能 查找O(1)、插入和删除O(n) 查找O(n)、插入和删除O(1) 空间性能 需要预分配存储空间，大了浪费，小了上溢 不需要预先分配存储空间 总结： 1）当线性...
线性表数据结构
04-28
线性表数据结构 线性表是一种基本的数据结构，它是一种由连续的存储单元组成的集合，每个存储单元称为元素。在C++语言中，线性表可以使用数组或链表来实现。在本文中，我们将介绍线性表的动态分配顺序存储结构和...
线性表 数据结构
07-07
数据结构 线性表 用C语言构造线性表来进行相关操作
线性表数据结构试验.pdf
10-01
线性表是一种基础且重要的数据结构，它是由n（n≥0）...总之，这个实验旨在帮助学生理解和熟练运用线性表数据结构，包括顺序存储和链式存储的特点以及相关操作的实现，为后续更复杂的数据结构和算法学习打下坚实基础。
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 510
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1139
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
【算法】贪心+堆排序实现大根堆及标准库容器类的融合使用
2301_77954967的博客
09-25 1772
先看题这个算法，是要通过循环找到所有元素中最大的那个偶元素，对其除以2，然后再找这之后的最大的那个偶元素以此类推笔者的经历不多，第一次做的时候没有想到大根堆的算法，只是用sort将每次除以2后的整个数组进行降序排序，这样的作法使用sort对数组进行排序后，虽然可以确定数组中的元素大小顺序，但在每次选择偶数进行减半操作时，需要遍历整个数组来找到合适的偶数，效率较低。对于一个较大的数组，排序后可能需要花费较多的时间来找到下一个要进行减半操作的偶数，尤其是当操作次数较多时，这种遍历的方式会变得非常耗时。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 424
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
算法宝典——二分查找算法
最新发布
2301_80689220的博客
09-28 169
初识算法之二分查找
文档矫正算法：DocTr++
Guo_Python的博客
09-23 435
论文提出了一种新的数据处理方式，解决了以前文档矫正只能处理带有边界信息的完整文档，文章通过数据处理定义了三种类型的训练数据。（a）包含完整文档边界，（b）包含部分文档边界，（c）不包含文档边界。算法框架如下：对于任意弯曲的文档，作者首先通过CNN抽取特征，然后通过transformer结构进行编码和解码，最后用Flow Head预测偏移场，用偏移场矫正弯曲图片。
Python实现Phong着色模型算法
qq_42568323的博客
09-24 1315
通过本文的介绍，我们详细阐述了Phong着色模型的基本原理，并使用Python实现了相关的算法。通过定义向量、光源、材质和着色器等类，我们可以灵活地计算光照和着色效果，为更复杂的三维图形渲染打下基础。Phong着色模型是计算机图形学中的经典光照模型，尽管随着技术的发展，出现了更复杂的光照模型（如Blinn-Phong、物理基础渲染等），但其简洁明了的特点仍然使其在许多应用中得以广泛使用。希望通过本次学习，读者能够深入理解Phong着色模型，并能够在实际项目中应用该算法。
全栈项目小组【算法赛】题目及解题
2201_75648436的博客
09-22 512
全栈项目小组【算法赛】
数位dp(算法篇)
hellmorning的博客
09-23 1114
数位dp也就是将动态规划的思想放入到对数的每一位进行，也是一种动态规划的一种，本篇文章将会带大家简单学习一下
C语言实现线性表数据结构
"这篇文档是关于在C语言中实现数据结构中的线性表结构，主要包含线性表的初始化、元素插入、查找、遍历等基本操作。代码使用了结构体来表示顺序线性表，并提供了相关的函数实现。" 线性表是一种基本的数据结构，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值