文章目录

• • 顺序表
  • 1. 顺序表的存储结构定义
  • 2. 顺序表的实现
  • • 2.1 初始化顺序表
    • 2.2 建立顺序表
    • 2.3 销毁顺序表
    • 2.4 判空操作
    • 2.5 求顺序表的长度
    • 2.6 遍历操作
    • 2.7 按值查找
    • 2.8 按位查找
    • 2.9 插入操作
    • 2.10 删除操作
  • 3. 顺序表的使用
  • 4. 暖暖树洞

顺序表

线性表的顺序存储结构称为顺序表，其基本思想是用一段地址连续的存储单元一次存储线性表的数据元素。

设顺序表的每个元素占用 c 个存储单元，则第 i 个元素的存储地址为：

所以，只要确定了存储顺序表的起始地址（即基地址），计算任意一个元素的存储地址的时间是相等的。

我们通常用一维数组来实现顺序表，也就是把线性表中相邻的元素存储在数组中相邻的位置，从而导致数据元素的序号和存放它的数组下标之间具有一一对应的关系。

$注意：$
C语言中数组的下标是 从0开始 的，而顺序表中元素的序号是 从1开始 的，即线性表中第 i 个元素存储在数组中下标为 i-1 的位置。

定义一个数组必须确定数组的长度。由于线性表中可以进行插入操作，所以数组长度要大于当前线性表的长度。用MaxSize表示数组长度，用length表示线性表的长度。

1. 顺序表的存储结构定义

#define MaxSize 100  //假设顺序表最多存放100个元素
typedef int DataType;	//定义线性表的数据类型，假设为int型

typedef struct
{
	DataType data[MaxSize];	//存放数据元素的数组
	int length;	//线性表的长度
}SeqList;

2. 顺序表的实现

2.1 初始化顺序表

初始化顺序表只需要将顺序表的长度length初始化为0,

void InitList(SeqList* L)
{
	L->length = 0;
}

2.2 建立顺序表

建立一个长度为n的顺序表，需要将给定的数据元素传入顺序表中，并将传入的元素个数作为顺序表的长度。

设给定的数据元素存放在数组a[n]中，建立顺序表的操作如图:

函数CreatList的返回值表示建立顺序表操作是否成功，如果顺序表的存储空间小于给定数据元素个数，则无法建立顺序表。

int CreatList(SeqList* L, DataType a[], int n)
{
	if (n > MaxSize)
	{
		printf("顺序表的存储空间不够，无法建立顺序表\n");
		return 0;
	}
	for (int i = 0; i < n; i++)
	{
		L->data[i] = a[i];
	}
	L->length = n;
	return 1;
}

2.3 销毁顺序表

顺序表是静态存储分配，在顺序表变量退出作用域时，自动释放该变量所占内存单元。因此，顺序表无须销毁。

2.4 判空操作

顺序表的判空操作只需要判断长度length是否为0就可以了，

int Empty(SeqList* L)
{
	if (L->length == 0) {
		return 1;	//顺序表为空返回1
	}
	else
	{
		return 0;
	}
}

2.5 求顺序表的长度

int Length(SeqList* L)
{
	return L->length;
}

2.6 遍历操作

在顺序表中，遍历操作即是按下标依次输出各元素

void PrintList(SeqList* L)
{
	for (int i = 0; i < L->length; i++)
	{
		printf("%d ", L->data[i]);	//输出线性表的元素值，假设为int型
	}
}

2.7 按值查找

在顺序表中实现按值查找操作，需要对顺序表中的元素依次进行比较，如果查找成功，返回元素的序号（注意不是下标）,否则返回0

int Locate(SeqList* L, DataType x)
{
	for (int i = 0; i < L->length; i++)
	{
		if (L->data[i] == x)
		{
			return i + 1;	//返回序号
		}
	}
	return 0;	//循环结束，说明查找失败
}

2.8 按位查找

顺序表中第i个元素存储在数组中下标为i-1的位置，
所以，很容易实现按位查找。

函数Get的返回值表示是否查找成功，若查找成功，通过指针参数ptr返回查找到的元素值。

int Get(SeqList* L, int i, DataType* ptr)
{
	if (i<1 || i>L->length)
	{
		printf("查找位置非法，查找失败\n");
		return 0;
	}
	else
	{
		*ptr = L->data[i - 1];
		return 1;
	}
}

2.9 插入操作

插入操作是在表的第i（1≦i≦n+1）个位置进行插入新元素x,使长度为n的线性表变成了长度为n+1的线性表。

$注意：$
元素移动的方向，是从最后一个元素开始移动，直至将第i个元素后移为止，然后将新元素插入i处。如果表满，则引发上溢错误，如果元素的插入位置不合法，则引发位置错误。

int Insert(SeqList* L, int i, DataType x)
{
	if (L->length >= MaxSize)
	{
		printf("上溢错误，插入失败");
		return 0;
	}
	if (i<1 || i>L->length + 1)
	{
		printf("位置错误，插入失败");
		return 0;
	}
	for (int j = L->length; j >= i; j--)
	{
		L->data[j] = L->data[j - 1];
	}
	L->data[i - 1] = x;
	L->length++;
	return 1;
}

2.10 删除操作

删除操作是将表的第i（1≦i≦n）个元素删除,使长度为n的线性表变成了长度为n-1的线性表。

$注意：$
元素移动的方向，是从第 i+1 个元素（下标为i）开始移动，直至将最后一个元素前移为止，并且在移动元素之前取出被删元素。如果表空，则引发下溢错误，如果元素的删除位置不合理，则引发位置错误。

int Delete(SeqList* L, int i, DataType* ptr)
{
	if (L->length == 0)
	{
		printf("下溢错误，删除失败\n");
		return 0;
	}
	if (i<1 || i>L->length)
	{
		printf("位置错误，删除失败\n");
		return 0;
	}
	*ptr = L->data[i - 1];	//取出位置i的元素
	for (int j = i ; j < L->length; j++)
	{
		L->data[j - 1] = L->data[j];
	}
	L->length--;
	return 1;
}

3. 顺序表的使用

#include<stdio.h>
#include<stdlib.h>
/*将顺序表的存储结构定义和各个函数定义放到这里*/

int main()
{
	int r[5] = { 1,2,3,4,5 }, i, x;
	SeqList L;	//定义变量L为顺序表类型
	CreatList(&L, r, 5);	//建立具有5个元素的顺序表
	printf("当前线性表的数据为：");
	PrintList(&L);	//输出当前线性表 1 2 3 4 5
	Insert(&L, 2, 8);	//在第2个位置插入值为8的元素
	printf("插入之后的数据为：");
	PrintList(&L);	//输出插入后的线性表 1 8 2 3 4 5
	printf("当前线性表的长度为：%d\n", Length(&L));	//输出线性表的长度6
	printf("请输入查找的元素值：");
	scanf("%d", &x);
	i = Locate(&L, x);
	if (i == 0)
	{
		printf("查找失败\n");
	}
	else
	{
		printf("元素%d的位置为：%d\n", x, i);
	}
	printf("请输入查找第几个元素的值:");
	scanf("%d", &i);
	if (Get(&L, i, &x) == 1)
	{
		printf("第%d个元素的值为：%d\n", i, x);
	}
	else
	{
		printf("线性表中没有第%d个位置元素\n",i);
	}
	printf("请输入要删除第几个元素：");
	scanf("%d", &i);
	if (Delete(&L, i, &x) == 1)
	{
		printf("删除成功，删除的数据为%d\n", x);
	}
	else
	{
		printf("删除操作失败\n");
	}
	return 0;
}

4. 暖暖树洞

“要留点精力去读书去运动去爱人，去奔赴想要的生活，不应该把精力浪费在痛苦的社交讨厌的人那里，看起来可以挽回的事情，仔细想想一点都不值得，贪恋过去的快乐注定走不远，过去的就让它过去吧，在热爱生活的同时快乐的小事情真的很多很多。”