线性表——顺序表

已于 2024-01-27 11:06:13 修改
阅读量853 收藏 16
点赞数 22
分类专栏： 数据结构 文章标签： 算法 c语言
于 2024-01-27 11:04:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77631043/article/details/135631199
版权

线性表——顺序表

1. 线性表

  线性表：0 个或多个数据元素的有限序列。（这些数据元素具有相同特性） 如果还不太理解，那就这样来说把，线性表，从字面上来理解就是 具有线一般特性的表 ，再把一条线分为好多段，每一段就是一个数据元素，注意这里的线是一个抽象概念。不难发现，线性表中的数据元素都是一对一的关系。我们常说的顺序表和链表也都属于线性表。
  若将线性表中的数据元素记为 L1，L2，L3，L4,······，Ln-2，Ln-1，Ln ; 我们称 L2 是 L3 的直接前驱元素，而 L4 是 L3 的直接后继元素，也对数据元素 Li 的下标定义，称 i 是 Li 在线性表中的位序，以此类推······ 在一个表中，第一个数据元素只有直接后继，最后一个数据元素只有直接前驱，当然表中也可以没有数据元素，这种表称之为空表。
  前面说到数据元素具有相同的特性，数据元素是一个庞大的概念，是不是一个数据元素只能存在一个数据项呢？这样的话其实很不方便，所以在有些复杂的顺序表中，一个数据元素可以是多个数据项组合而成的。就比如学校的系统中存着学生信息，学生信息并不只有一个姓名，而是由学号、姓名、年龄、联系电话等数据组合，最后再按特定的方法有序存放。
  线性表是一种逻辑结构，它有两种物理结构：顺序存储结构、链式存储结构。

2. 顺序存储结构

  线性表的顺序存储结构，指的是用一段地址连续的存储单元 依次存储线性表的数据元素。由于数据元素的属性（类型）都相同，顺序表的实现离不开数组。使用顺序存储结构的线性表简称为 顺序表 。

  • 线性表地址的计算：

  顺序表要使用一段地址连续的存储单元进行存放数据，要想计算数据元素具体的地址（前提是首个数据元素位置确定），下面就有一个公式计算第 i 个数据元素 Li 的存储位置：

  LOC( Li ) = LOC( L1 ) + ( i - 1 ) * c
  说明：c 表示元素占用存储单元的长度

  • 顺序表的两种分配方式：
  1. 静态顺序表：使用静态分配，在定义数组时，直接使用定长数组（给定数组一个确定的大小）。
  2. 动态顺序表：使用动态分配，数组大小可根据需要改变，一般使用malloc、realloc 等函数进行操作。（这种分配方式用得最多）

若不熟悉 malloc、realloc 可参考：动态内存管理

3. 顺序表的实现

3.1 顺序表的定义

  我们先进行一些基础操作（这里我们对动态顺序表进行实现）

typedef int SLDataType;

typedef struct Sqlist
{
	SLDataType x;	//插入元素，在顺序表的插入中会用到
	int* a;			//动态数组指针，暂未给定大小
	int size;		//有效数据
	int length;		//空间大小
}SL;

图解：
顺序表的定义

3.2 顺序表的初始化

  由于需要对部分数据进行修改，传参时只能传地址，所以用的是传址调用。

void SLInit(SL* psl)
{
	assert(psl);	//判断psl是否为空

	psl->a = NULL;
	psl->size = 0;
	psl->length = 0;
}

assert 断言可参考：assert

3.3 顺序表的销毁

void SLDestory(SL* psl)
{
	assert(psl);		//判断psl是否为空

	if (psl->a != NULL)
	{
		free(psl->a);	//释放动态开辟的内存空间
		psl->a = NULL;	//释放后指针及时置空
		psl->size = 0;
		psl->length = 0;
	}
}

3.4 顺序表的插入

  插入数据的操作就是对数组的修改，存入数据，既然是存放数据，就要考虑内存空间够不够用，就需要先对数组的空间大小进行判断，这里我们可以将判断部分进行封装。

既然顺序表要插入数据，那就要给插入的数据留一个空位进行存放，所以插入的操作就是要对顺序表中的数据进行部分移动。

3.4.1 检查存储空间

void SLChecklength(SL* psl)
{
	assert(psl);		//判断psl是否为空

	if (psl->size >= psl->length)		//是否空间不够
	{
		int newlength = psl->length == 0 ? 4 : psl->length * 2;  //判断length是否为零
		//上一行使用三目操作符，若length为零，则给newlength 4或8的空间大小；不为零newlength则扩大为原来的2倍（2倍不是固定的值，而是最能接受的一个值，可自行更改，）
		SLDataType* tmp = (SLDataType*)realloc(psl->a, sizeof(SLDataType) * newlength);
		//对tmp进行动态内存开辟，扩容操作
		if (tmp == NULL)
		{
			perror("realloc fail");		//扩容失败
			return;
		}
		psl->a = tmp;
		psl->length = newlength;
	}
}

3.4.2 头部插入（头插）

  头插需要将整个数组的数据元素向后移动，再插入数据，才能保证数据正确。

void SLPushFront(SL* psl, SLDataType x)	//头插
{
	assert(psl);

	SLChecklength(psl);			//保证有空间可插入

	int end = psl->size - 1;	
	while (end >= 0)			//数据整体向后移动（覆盖）
	{
		psl->a[end + 1] = psl->a[end];	
		--end;
	}

	psl->a[0] = x;		//插入数据x
	psl->size++;		//有效数据个数＋1
}

图解：
头插

3.4.3 尾部插入（尾插）

  尾插就不用移动数据，直接在末端插入即可。

void SLPushBack(SL* psl, SLDataType x)		//尾插
{
	assert(psl);

	SLChecklength(psl);		//保证空间足够
	psl->a[psl->size] = x;
	psl->size++;
}

3.4.4 指定位置插入

void SLInsert(SL* psl, int pos, SLDataType x)	//pos表示下标，x表示要插入的数据
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);		//判断pos的取值在范围内
	
	SLChecklength(psl); 		//保证空间足够

	int end = psl->size - 1;
	while (end >= pos)
	{
		psl->a[end + 1] = psl->a[end];		//向后移动数据操作(覆盖)
		--end;
	}
	
	psl->a[pos] = x;		//在指定位置插入
	psl->size++;			//有效数据长度 + 1
}

3.5 顺序表的删除

3.5.1 头部删除（头删）

void SLPopFront(SL* psl)		//头删
{
	assert(psl);

	//判断psl->size(有效数据)是否为空
	
	//方法1：
	//if (psl->size == 0)
	//{
	//	return;
	//}
	
	//方法2：
	assert(psl->size > 0);	//为假报错（断言）

	int begin = 0;
	while (begin < psl->size)
	{
		psl->a[begin] = psl->a[begin + 1];		//数据整体向前覆盖
		++begin;
	}
	psl->size--;
}

图解：
头删

3.5.2 尾部删除（尾删）

void SLPopBack(SL* psl)		//尾删
{
	assert(psl);

	//判断psl->size(有效数据)是否为空
	
	//方法1：
	//if (psl->size == 0)
	//{
	//	return;
	//}
	
	//方法2：
	assert(psl->size > 0);	//为假报错（断言）

	psl->size--;		//原数组最后一个有效数据变为无效数据，就不用覆盖再删除
}

3.5.3 指定位置删除

void SLErase(SL* psl, int pos)
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);	//判断pos的取值在范围内

	int begin = pos;

	while (begin < psl->size)
	{
		psl->a[begin] = psl->a[begin + 1];		//数据整体向前覆盖
		++begin;
	}
	
	psl->size--;		//删除后有效数据长度 - 1
}

3.6 顺序表的查找

void SLFind(SL* psl, SLDataType x)
{
	assert(psl);

	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			printf("%d的下标是%d\n", x, i);
		}
	}
	return -1;
}

3.7 顺序表的打印

void SLPrint(SL* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

以上操作可再通过接口实现

4. 功能综合

  顺序表功能综合实现如下，另外加入了菜单功能，帮助更快对部分功能进行熟悉。（可自行加入代码增加鲁棒性）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLDataType;

typedef struct Sqlist
{
	SLDataType x;	//插入元素，在顺序表的插入中会用到
	int* a;			//动态数组指针，暂未给定大小
	int size;		//有效数据
	int length;		//空间大小
}SL;

void SLInit(SL* psl)
{
	assert(psl);	//判断psl是否为空

	psl->a = NULL;
	psl->size = 0;
	psl->length = 0;
}

void SLDestory(SL* psl)
{
	assert(psl);		//判断psl是否为空

	if (psl->a != NULL)
	{
		free(psl->a);	//释放动态开辟的内存空间
		psl->a = NULL;	//释放后指针及时置空
		psl->size = 0;
		psl->length = 0;
	}
}

void SLChecklength(SL* psl)
{
	assert(psl);		//判断psl是否为空

	if (psl->size >= psl->length)		//是否空间不够
	{
		int newlength = psl->length == 0 ? 4 : psl->length * 2;  //判断length是否为零
		//上一行使用三目操作符，若length为零，则给newlength 4或8的空间大小；不为零newlength则扩大为原来的2倍（2倍不是固定的值，而是最能接受的一个值，可自行更改，）
		SLDataType* tmp = (SLDataType*)realloc(psl->a, sizeof(SLDataType) * newlength);
		//对tmp进行动态内存开辟，扩容操作
		if (tmp == NULL)
		{
			perror("realloc fail");		//扩容失败
			return;
		}
		psl->a = tmp;
		psl->length = newlength;
	}
}

void SLPushFront(SL* psl, SLDataType x)	//头插
{
	assert(psl);

	SLChecklength(psl);			//保证有空间可插入

	int end = psl->size - 1;
	while (end >= 0)			//数据整体向后移动（覆盖）
	{
		psl->a[end + 1] = psl->a[end];
		--end;
	}

	psl->a[0] = x;		//插入数据x
	psl->size++;		//有效数据个数＋1
}

void SLPushBack(SL* psl, SLDataType x)		//尾插
{
	assert(psl);

	SLChecklength(psl);		//保证空间足够
	psl->a[psl->size] = x;
	psl->size++;
}

void SLInsert(SL* psl, int pos, SLDataType x)	//pos表示下标，x表示要插入的数据
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);		//判断pos的取值在范围内

	SLChecklength(psl); 		//保证空间足够

	int end = psl->size - 1;
	while (end >= pos)
	{
		psl->a[end + 1] = psl->a[end];		//向后移动数据操作(覆盖)
		--end;
	}

	psl->a[pos] = x;		//在指定位置插入
	psl->size++;			//有效数据长度 + 1
}

void SLPopFront(SL* psl)		//头删
{
	assert(psl);

	//判断psl->size(有效数据)是否为空

	//方法1：
	//if (psl->size == 0)
	//{
	//	return;
	//}

	//方法2：
	assert(psl->size > 0);	//为假报错（断言）

	int begin = 0;
	while (begin < psl->size)
	{
		psl->a[begin] = psl->a[begin + 1];		//数据整体向前覆盖
		++begin;
	}
	psl->size--;
}

void SLPopBack(SL* psl)		//尾删
{
	assert(psl);

	//判断psl->size(有效数据)是否为空

	//方法1：
	//if (psl->size == 0)
	//{
	//	return;
	//}

	//方法2：
	assert(psl->size > 0);	//为假报错（断言）

	psl->size--;		//原数组最后一个有效数据变为无效数据，就不用覆盖再删除
}

void SLErase(SL* psl, int pos)
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);	//判断pos的取值在范围内

	int begin = pos;

	while (begin < psl->size)
	{
		psl->a[begin] = psl->a[begin + 1];		//数据整体向前覆盖
		++begin;
	}

	psl->size--;		//删除后有效数据长度 - 1
}

void SLFind(SL* psl, SLDataType x)
{
	assert(psl);

	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			printf("%d的下标是%d\n", x, i);
		}
	}
	return -1;
}

void SLPrint(SL* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

void menu()
{
	printf("================================\n");
	printf("1.尾插		2.尾删\n");
	printf("3.头插		4.头删\n");
	printf("5.打印		0.退出\n");
	printf("================================\n");
}

int main()
{
	SL s;
	SLInit(&s);

	int choose = 0;
	do				//这里可以用if 替换do...while、switch...case
	{
		menu();
		printf("请输入选项：");
		scanf("%d", &choose);
		switch (choose)
		{
		case 1:
			printf("请输入要插入的数据个数和数据：");
			int a = 0;
			scanf("%d", &a);
			for (int i = 0; i < a; i++)
			{
				int x = 0;
				scanf("%d", &x);
				SLPushBack(&s, x);
			}
			break;
		case 2:
			SLPopBack(&s);
			printf("操作已完成\n");
			break;
		case 3:
			printf("请输入要插入的数据个数和数据：");
			int b = 0;
			scanf("%d", &b);
			for (int i = 0; i < b; i++)
			{
				int x = 0;
				scanf("%d", &x);
				SLPushBack(&s, x);
			}
			break;
		case 4:
			SLPopFront(&s);
			printf("操作已完成\n");
			break;
		case 5:
			SLPrint(&s);
			break;
		case 0:
			printf("退出.......");
			break;
		default:
			printf("请输入正确的选项......");
			break;
		}
	} while (choose);

	SLDestory(&s);

	return 0;
}

5. 顺序表的优缺点

优点：

  1. 顺序表的物理空间是连续的，不用为数据间的逻辑关系增加额外存储空间。
  2. 可以通过下标进行访问（访问方便）。

缺点：

  1. 尾部插入数据效率高，头部和中间插入删除，需要移动数据，效率较低。
  2. 当空间不够时会进行扩容，而扩容会有一定消耗，也存在一定的空间浪费（扩多了浪费，少了不够，就需要频繁扩容）。

6. 链表

  传送门：链表(点击传送)

许小燚
关注
专栏目录
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
### 数据结构C++ 线性表——顺序表和单链表基本操作 #### 一、概述 在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并...
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案 线性表是一种典型的线性结构，其基本特点是线性表中的数据元素是有序且是有限的。线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有...
线性表——链表PPT学习教案.pptx
10-01
链表的操作，如插入和删除，通常比顺序存储的线性表更灵活，因为它们主要涉及到节点之间的指针修改，而不需要像顺序表那样移动大量元素。然而，这也意味着链表的访问速度可能较慢，因为必须从头节点开始遍历，寻找...
小白算法积累——顺序表5#无序顺序表+删除范围
01-07
题目：从顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行。 关键词：无序顺序表 删除范围 思路： 1.遍历扫描顺序表L，用k记录下当前...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 390
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1112
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 267
试除法求约数、约数个数、约数之和、最大公约数
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1152
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 929
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 442
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 418
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 1561
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
代码随想录算法训练营day18|二叉树06
gyuhyhui的博客
09-10 778
示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到，那么中节点的处理逻辑，下面讲解。例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
算法里面的离散化
admin_zbn的博客
09-11 887
离散化的主要目的是将连续的值或大范围的值映射到一个有限的集合中，以便进行高效的存储和处理。这通常通过对连续的数据进行排序、分组、或者映射来实现。离散化的关键是将原始的、可能是连续或无限范围的数据，转化为有限且可处理的编号或索引。这样不仅优化了存储空间，也提高了数据处理的效率。二、在算法中，“映射”是指将一个集合中的每个元素通过某种规则或函数转换为另一个集合中的元素的过程。这一概念广泛应用于数据处理、函数设计和数据结构中。
18068 选择排序
huang1xiao1sheng的博客
09-11 390
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
Acwing 区间合并
qq_43060884的博客
09-14 960
区间合并，还在模拟吗？
DFS 算法：洛谷B3625迷宫寻路
Python_enjoy 是一个大帅哥！
09-07 1060
这永远不是最后一篇讲解算法的文章
tcp线程进程多并发
2301_78756095的博客
09-11 885
printf("收到%s:%d的信息%s\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),buff);printf("%s:%d客户端连接\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port));printf("%s:%d连接成功\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port));if(signal(SIGCHLD,hande)==SIG_ERR)//捕获子进程退出的信号。
约瑟夫环问题与线性表——顺序与链式存储
线性表的顺序存储结构（顺序表）将所有元素存储在一块连续的内存空间中，访问速度快，但插入和删除操作可能涉及大量元素的移动。而链式存储结构（链表）则通过节点间的指针链接元素，插入和删除操作相对灵活，但访问...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值