线性表之顺序表（增删查改）详解

🍕博客主页：️自信不孤单

🍬文章专栏：数据结构与算法

🍚代码仓库：破浪晓梦

🍭欢迎关注：欢迎大家点赞收藏+关注

---

🍉线性表

• 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

• 线性表在逻辑上是线性结构，也就是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

  补充

  • 逻辑结构：数据元素之间的逻辑关系,即人对数据的理解,而进行抽象的模型。
  • 物理结构 ：数据元素在计算机中的存储方法,即计算机对数据的理解,逻辑结构在计算机语言中的映射。

🍒顺序表

1. 概念及结构

概念

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。

结构

顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储元素。

#define N 10
typedef int SLDataType;
												
typedef struct SeqList
{
	SLDataType array[N];  //定长数组
	size_t size;          //有效数据个数
}SeqList;

2. 动态顺序表：使用动态开辟的数组存储。

typedef int SLDataType; //类型重命名，后续要存储其它类型时方便更改
												
typedef struct SeqList
{
	SLDataType* a;    //指向动态开辟的数组
	size_t size;      //有效数据个数
	size_t capacity;  //容量大小
}SeqList;

2. 接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

首先创建两个文件实现动态顺序表：

• SeqList.h（顺序表的类型声明、接口函数声明、头文件的包含）
• SeqList.c（顺序表接口函数的实现）

接着创建 test.c 文件来测试各个接口

如图：

SeqList.h 文件内容如下：

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDataType x);
void SeqListPushFront(SeqList* ps, SLDataType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);
//修改pos位置的值为x
void SeqListModify(SeqList* ps, int pos, SLDataType x);

接下来，我们在 SeqList.c 文件中实现各个接口函数。

2.1 初始化顺序表

初始化开辟5个数据的空间。

void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 5);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->capacity = 5;
	ps->size = 0;
}

2.2 销毁顺序表

void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

2.3 检查顺序表容量

若顺序表已满，则扩容为原容量的2倍。

void CheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("reallo fail");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

2.4 顺序表尾插

注意检查容量。

void SeqListPushBack(SeqList* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

2.5 顺序表尾删

注意原数据个数要大于0，才可执行删除操作。

void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;
}

2.6 顺序表头插

所有数据依次向后挪动一个数据的位置，再将要插入的数据放在第一位。
注意挪动要从后往前进行，防止有效数据覆盖。

void SeqListPushFront(SeqList* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	for (int i = ps->size; i >= 1; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}

2.7 顺序表头删

判断原数据个数要大于0，才可执行删除操作。
从第二位开始依次向前挪动一个数据的位置，将第一个数据覆盖。
注意挪动要从前往后进行，防止有效数据覆盖。

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i+1];
	}
	ps->size--;
}

2.8 打印顺序表

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

2.9 查找指定值

找到返回指定值的下标，否则返回-1。

int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

2.10 在指定下标位置插入数据

首先需判断插入的位置是否越界。
然后检查容量。
从指定位置开始依次向后挪动一个数据，再将要插入的数据放在指定的位置上。
注意挪动要从后往前进行，防止有效数据覆盖。

void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	CheckCapacity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos] = x;
	ps->size++;
}

2.11 删除指定下标位置的数据

判断原数据个数要大于0，才可执行删除操作。
从第指定位置开始依次向前挪动一个数据的位置，将指定位置数据覆盖。
注意挪动要从前往后进行，防止有效数据覆盖。

void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

2.12 修改指定下标位置的数据

void SeqListModify(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

注：在每个接口函数中一定要使用assert函数断言防止对空指针的引用。

补充对于越界的理解：

越界不一定报错，系统对越界的检查是一种抽查。

• 越界读一般是检查不出来的。
• 越界写如果是修改到标志位才会检查出来。（系统在数组末尾后设有标志位，越界写时，恰好修改到标志位了，就会被检查出来）

3. 接口测试

test.c 文件内容如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"

void test()
{
	//创建顺序表
	SeqList sl;
	//初始化
	SeqListInit(&sl);
	//尾插
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);
	//头插
	SeqListPushFront(&sl, 1);
	SeqListPrint(&sl);
	SeqListPushFront(&sl, 0);
	SeqListPrint(&sl);
	//尾插
	SeqListPushBack(&sl, 6);
	SeqListPrint(&sl);
	//指定插
	SeqListInsert(&sl, 2, 2);
	SeqListPrint(&sl);
	SeqListInsert(&sl, 3, 3);
	SeqListPrint(&sl);
	SeqListInsert(&sl, 4, 4);
	SeqListPrint(&sl);
	//查找
	int n = SeqListFind(&sl, 4);
	printf("查找数据4的下标为:>%d\n", n);
	//尾删
	SeqListPopBack(&sl);
	SeqListPrint(&sl);
	//头删
	SeqListPopFront(&sl);
	SeqListPrint(&sl);
	//指定删
	SeqListErase(&sl, 3);
	SeqListPrint(&sl);
	//修改位置3的数据为4
	SeqListModify(&sl, 3, 4);
	SeqListPrint(&sl);
	//销毁顺序表
	SeqListDestroy(&sl);
}

int main()
{
	test();
	return 0;
}

运行结果：

---