线性表的顺序存储结构

零、无关内容

线性表的顺序存储结构是计算机科学中的一种基础且重要的数据存储方式，它利用内存中的连续空间来存放数据元素的线性集合。这种存储方式不仅易于实现，而且能够提供较快的存取速度，适用于大量数据的高效管理。

1、线性表顺序存储结构的基本概念

线性表的顺序存储结构是指在内存中开辟一块连续的存储区域，按照一定的顺序存放线性表的各个数据元素。每个数据元素占用固定的存储单元，它们之间的逻辑关系通过物理上的相邻位置来体现。这种存储方式与数组非常相似，可以将线性表简单地视为一个数组，其中的每个数组元素对应线性表中的一个数据元素。

2、顺序存储结构的特点

1. 随机访问：由于数据元素在内存中是连续存放的，可以通过计算元素的相对位置直接访问任何元素，实现随机访问。
2. 存储空间连续：线性表的数据元素在物理上紧挨着存储，中间没有空隙，这有利于节省存储空间。
3. 插入和删除操作复杂：在顺序存储结构中，插入或删除一个数据元素时，需要移动大量元素以保持存储区的连续性，这导致操作的时间成本较高。
4. 空间分配固定：顺序存储结构的存储空间通常是预先分配的，大小固定，不利于动态扩展。

3、顺序存储结构的实现

实现线性表的顺序存储结构，通常需要定义一个足够大的数组以及相应的控制变量（如表长）来管理线性表的状态。

1. 数组定义：根据线性表的最大容量，定义一个相应大小的数组。
2. 初始化：将线性表的表长初始化为0，表示表初始为空。
3. 数据操作：通过数组索引实现线性表的查找、插入、删除等操作。例如，访问第i个数据元素时，可以直接通过数组索引i-1进行访问（假设数组索引从0开始）。

4、顺序存储结构的优缺点分析

1. 优点：

• 访问速度快：顺序存储结构可以快速地访问任意位置的数据元素。
• 简单易用：使用数组来存储数据，结构简单，容易理解和使用。
• 空间利用率高：除了预留的空间外，几乎全部空间都被利用于数据存储。

2. 缺点：

• 插入和删除操作效率低：需要在数组中移动大量元素，特别是对于大型表来说，成本很高。
• 大小固定：数组一旦初始化，大小通常不易改变，这限制了线性表的动态扩展能力。
• 空间可能浪费：一旦分配的空间未被完全使用，就会造成空间浪费。

5、顺序存储结构的应用

尽管存在一些缺点，顺序存储结构因其简洁和高效的特点，在许多场合下仍然非常有用。例如，在数据规模固定、查询操作远多于插入和删除操作的应用场景中，顺序存储结构是一个非常好的选择。此外，顺序存储结构也常用于算法的基础结构，如排序和搜索算法中。

总之，线性表的顺序存储结构是一种基本而重要的数据存储方式，它通过连续的内存空间实现了高效的数据存储和访问。虽然在插入和删除操作上存在一定的局限性，但其简单的结构和快速的访问速度使其在许多应用中仍然是首选。理解其特点和适用场景，对于合理利用这一数据结构至关重要。

一、线性表的顺序存储结构

（一）基本原理

设线性表的第一个元素在内存中的存储地址为 $location(a_0)$，每个元素的占用的空间大小为 $k$ 个存储单元，则任意元素的内存地址为：
$$location(a_i)=location(a_0)+k\ast i$$

优点：顺序存储，存储空间少，便于查找。
缺点：插入元素要移动全部的元素，速度慢。

（二）线性表的数据结构

typedef struct SeqList
{
	int n;
	int maxLength;
	ElemType *element;
}SeqList;

二、顺序表的数据结构实现

（一）顺序表的初始化

顺序表的舒适化是使用动态内存生成一个空的线性表。

Status Init(SeqList* list, int mSize)
{
	list->n = 0;
	list->maxLength = mSize;
	list->element = (ElemType*)malloc(sizeof(ElemType) * mSize);
	if (!list->element)
		return Error;
	return OK;
}

（二）顺序表的插入

顺序表的插入是指，若插入位置为 $i$，则将插入元素插入到原顺序表元素 $a_i$ 的后面。若插入位置为 $-1$，则将元素插入到头结点的位置。

1、算法步骤

（1）判断插入下标是否越界

（2）检查顺序表是否已满

（3）将元素（ai+1, ai+2, …, an-1）依次向后移动一个位置

（4）将新元素插入到 i+1 的位置

（5）表长 + 1

2、算法代码

Status Insert(SeqList* list, int i, ElemType x)
{
	if (i < 0 || i > list->n)
		return Error;
	if (list->n == list->maxLength)
		return Error;
	for (int j = list->n; j > i; j--)
		list->element[j] = list->element[j-1];
	list->element[i] = x;
	list->n = list->n + 1;
	return OK;
}

（三）顺序表的查找

因为顺序表采用顺序存储的方式进行存储，所以，我们只要有顺序表头结点的地址和所需查找元素在顺序表中的索引下标，我们即可找到所查找元素的内存地址，取出所要查找元素的值。

1、算法步骤

（1）算法步骤1：判断是否越界
（2）算法步骤2：取出所查找的值并返回

2、算法代码

Status Find(SeqList* list, int i, ElemType* x)
{
	if (i < 0 || i > list->n - 1)
		return Error;
	*x = list->element[i];
	return OK;
}

三、完整代码

#include <stdio.h>
#define ElemType int
#define Error 0
#define OK 1
#define Overflow 2
#define Underflow 3
#define NotPresent 4
#define Duplicate 5
typedef int Status;


typedef struct SeqList
{
	int n;
	int maxLength;
	ElemType *element;
}SeqList;

Status Init(SeqList* list, int mSize)
{
	list->n = 0;
	list->maxLength = mSize;
	list->element = (ElemType*)malloc(sizeof(ElemType) * mSize);
	if (!list->element)
		return Error;
	return OK;
}

Status Insert(SeqList* list, int i, ElemType x)
{
	if (i < 0 || i > list->n)
		return Error;
	if (list->n == list->maxLength)
		return Error;
	for (int j = list->n; j > i; j--)
		list->element[j] = list->element[j-1];
	list->element[i] = x;
	list->n = list->n + 1;
	return OK;
}

Status Find(SeqList* list, int i, ElemType* x)
{
	if (i < 0 || i > list->n - 1)
		return Error;
	*x = list->element[i];
	return OK;
}

int main()
{
	SeqList* list = malloc(sizeof(SeqList));
	Insert(list, 0, 0);
	int* x = malloc(sizeof(int));
	*x = Find(list, 0, x);
	printf("%d\n", *x);
	return 0;
}