【数据结构手札】顺序表实战指南（四）：头插 | 头删

🌈个人主页：聆风吟
🔥系列专栏：数据结构手札
🔖少年有梦不应止于心动，更要付诸行动。

---

文章目录

• 📚专栏订阅推荐
• [📋前言 - 顺序表文章合集](#📋前言 - 顺序表文章合集)
• [一. ⛳️顺序表：重点回顾](#一. ⛳️顺序表：重点回顾)
• • [1.1 🔔顺序表的定义](#1.1 🔔顺序表的定义)
  • [1.2 🔔顺序表的分类](#1.2 🔔顺序表的分类)
  • • [1.2.1 👻静态顺序表](#1.2.1 👻静态顺序表)
    • [1.2.2 👻动态顺序表](#1.2.2 👻动态顺序表)
• [二. ⛳️顺序表的基本操作实现](#二. ⛳️顺序表的基本操作实现)
• • [2.1 🔔头插](#2.1 🔔头插)
  • [2.2 🔔头删](#2.2 🔔头删)
• [三. ⛳️顺序表的源代码](#三. ⛳️顺序表的源代码)
• • [3.1 🔔SeqList.h 顺序表的函数声明](#3.1 🔔SeqList.h 顺序表的函数声明)
  • [3.2 🔔SeqList.c 顺序表的函数定义](#3.2 🔔SeqList.c 顺序表的函数定义)
  • [3.3 🔔test.c 顺序表功能测试](#3.3 🔔test.c 顺序表功能测试)
• 📝全文总结

📚专栏订阅推荐

专栏名称	专栏简介
数据结构手札	本专栏主要是我的数据结构入门学习手札，记录个人从基础到进阶的学习总结。
数据结构手札・刷题篇	本专栏是《数据结构手札》配套习题讲解，通过练习相关题目加深对算法理解。

📋前言 - 顺序表文章合集

-【顺序表（一）：线性表定义 | 顺序表定义】

-【顺序表（二）：初始化 | 打印 | 销毁】

-【顺序表（三）：扩容 | 尾插 | 尾删】

-【顺序表（四）：头插 | 头删】

-【顺序表（五）：查找 | 任意位置增删】

后续文章会陆续补充，尽情期待...

---

一. ⛳️顺序表：重点回顾

1.1 🔔顺序表的定义

顺序表（Sequential List）：用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下采用数组存储。在数组上完成数据的增删查改。

1.2 🔔顺序表的分类

顺序表一般可以分为：静态顺序表 和动态顺序表。

1.2.1 👻静态顺序表

**静态顺序表：指存储空间是固定的并且在程序运行前就已经确定大小的顺序表。**它通常使用数组来实现，即通过定义一个固定长度的数组来存储数据元素。

静态顺序表的结构定义：

//静态顺序表结构定义
#define MAXSIZE 7//存储单元初始分配量
typedef int SLDataType;//类型重命名，便于统一修改元素类型

typedef struct SeqList
{
	SLDataType data[MAXSIZE];//定长数组
	int size;//当前有效数据的个数
}SeqList;

我们可以发现描述静态顺序表需要三个属性：

• 存储空间的起始位置：数组data，他的存储位置就是存储空间的存储位置；
• 线性表的最大存储容量：数组长MAXSIZE；
• 线性表的当前位置：size。

1.2.2 👻动态顺序表

**动态顺序表：通过动态分配内存空间，实现随着数据量的增加而不断扩容的效果。**它的结构类似于一个数组，数据元素的存储是连续的，支持随机访问和顺序访问。

动态顺序表的结构定义：

//动态顺序表结构定义
typedef int SLDataType;//类型重命名，便于统一修改元素类型

typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组
	int size;//当前有效数据的个数
	int capacity;//当前分配的总容量
}SL;

我们可以发现描述动态顺序表也需要三个属性：

• 存储空间的起始位置：指针a，他里面存储的地址就是存储空间的地址；
• 线性表当前最大存储容量：capacity，可以通过动态分配的方式进行扩容；
• 线性表的当前位置：size。

---

二. ⛳️顺序表的基本操作实现

通过前面的学习，我们已掌握动态顺序表的结构体构建及初始化、打印、销毁、扩容、尾插、尾删等基础操作。本文将继续讲解顺序表中需要挪动数据的头插 、头删操作。

2.1 🔔头插

头插是在顺序表的第一个位置（下标为 0 的位置） 插入新元素，与尾插直接赋值不同，头插需要先将所有元素向后挪动一位 ，为新元素腾出第一个位置，否则会直接覆盖原有第一个元素。整个过程需先确保容量充足，在挪动数据，最后再完成插入并更新有效数据元素个数。
整体思路图解：

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	//检查顺序表指针有效性
	assert(ps);
	//检查是否需要扩容
	SLCheckCapacity(ps);
	
	//挪动数据：从最后一个有效元素开始，从后往前挪
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];//当前元素向后挪一位
		--end; //向前移动，处理下一个元素
	}

	ps->a[0] = x;//头插核心：新元素放入第一个位置
	ps->size++;//更新有效元素个数
}

关键代码解析：
（1）int end = ps->size - 1;

ps->size是有效元素个数，数组下标从 0 开始，因此最后一个有效元素的下标是 size - 1，这是数据挪动的 "起点"，必须从这个位置开始挪，才能避免数据覆盖。

（2）ps->a[0] = x;

所有元素挪位完成后，下标 0 的位置已空出，此时将新元素赋值到该位置，完成头插的核心赋值操作。

时间复杂度：

头插需要挪动顺序表中所有有效元素 ，元素个数为n时，需要执行n次挪动操作，因此时间复杂度为O(n)（n为顺序表当前有效元素个数）。

2.2 🔔头删

头删是删除顺序表第一个位置（下标为 0 的位置） 的元素，与尾删仅修改 size 的逻辑删除不同，头删需要将第一个元素之后的所有元素向前挪动一位 ，覆盖被删除的元素，最终通过 size-- 完成逻辑删除。整个过程需先确保顺序表非空，再挪动数据，最后更新有效元素个数。
整体思路图解：

//头删
void SLPopFront(SL* ps)
{
	//检查顺序表指针有效性
	assert(ps);

	//判断顺序表是否为空（暴力检查：空表直接报错）
	assert(ps->size > 0);
	
	//挪动元素向前覆盖：从第二个元素开始，依次覆盖前一个位置
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;//向后移动，处理下一个元素
	}

	ps->size--; //更新有效元素个数
}

关键代码解析：
（1）int begin = 1;

数组下标从 0 开始，第一个元素的下标是 0，第二个元素的下标是 1，这是数据挪动的 "起点"------ 只有从第二个元素开始向前挪，让原第二个元素占据下标 0 的位置，原第一个元素被 "覆盖删除"。

（2）ps->size--;

元素挪动完成后，必须将有效元素个数减 1，从逻辑上标记最后一个原有效元素为 "无效"（因为所有元素已前移，原最后一个元素的位置无需保留）；若漏写这一行，会导致后续遍历 / 删除操作访问到已被覆盖的 "残留数据"，引发数据统计错误。

时间复杂度：

头删需要挪动顺序表中除第一个元素外的所有有效元素 ，元素个数为n时，需要执行n-1次挪动操作，因此时间复杂度为O(n)（n为顺序表当前有效元素个数）。

---

三. ⛳️顺序表的源代码

3.1 🔔SeqList.h 顺序表的函数声明

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

//动态顺序表
#define SLCAPACITY 4
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组
	int size;//有效数据的个数
	int capacity;//记录容量的空间大小
}SL;

//******************** 本文最新学习内容 ********************
//头插
void SLPushFront(SL* ps, SLDataType x);
//头删 
void SLPopFront(SL* ps);

//******************** 前面已学习内容：可能会调用 ********************
//初始化
void SLInit(SL* ps);
//销毁顺序表
void SLDestroy(SL* ps);
//打印顺序表
void SLPrint(SL* ps);
//检查容量是否够，不够进行扩容
void SLCheckCapacity(SL* ps);

3.2 🔔SeqList.c 顺序表的函数定义

#include "SeqList.h"

//******************** 本文最新学习内容 ********************
//头插
void SLPushFront(SL* ps, SLDataType x)
{
	//检查顺序表指针有效性
	assert(ps);
	//检查是否需要扩容
	SLCheckCapacity(ps);
	
	//挪动数据：从最后一个有效元素开始，从后往前挪
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];//当前元素向后挪一位
		--end; //向前移动，处理下一个元素
	}

	ps->a[0] = x;//头插核心：新元素放入第一个位置
	ps->size++;//更新有效元素个数
}

//头删
void SLPopFront(SL* ps)
{
	//检查顺序表指针有效性
	assert(ps);

	//判断顺序表是否为空（暴力检查：空表直接报错）
	assert(ps->size > 0);
	
	//挪动元素向前覆盖：从第二个元素开始，依次覆盖前一个位置
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];//当前元素向前挪一位
		++begin;//向后移动，处理下一个元素
	}

	ps->size--; //更新有效元素个数
}

//******************** 前面已学习内容：可能会调用 ********************
//初始化顺序表
void SLInit(SL* ps)
{
	assert(ps);
	//使用malloc开辟空间
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * SLCAPACITY);
	//判断空间是否开辟成功
	if (NULL == ps->a)
	{
		//打印错误原因（比如 "malloc failed: Out of memory"），方便定位问题；
		perror("malloc failed");
		//终止程序并返回非 0 状态码（约定俗成表示程序异常退出），避免后续无效操作。
		exit(-1);
	}
	
	//初始化顺序表的有效元素个数为 0。
	ps->size = 0;
	//记录顺序表当前的最大容量。
	ps->capacity = SLCAPACITY;
}

//销毁顺序表
void SLDestroy(SL* ps)
{
	assert(ps);
	
	//释放顺序表底层数组占用的动态内存。
	free(ps->a);
	//将指针置空，避免 "野指针" 问题。
	ps->a = NULL;
	//重置顺序表的状态变量，让其回归 "初始无效状态"。
	ps->size = ps->capacity = 0;
}

//打印顺序表
void SLPrint(SL* ps)
{
	assert(ps);

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

//检查容量是否够，不够进行扩容
void SLCheckCapacity(SL* ps)
{
	//断言检查指针有效性
	assert(ps);

	//判断是否需要扩容
	if (ps->size == ps->capacity)
	{
		//使用realloc进行扩容
		SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * 2 * (ps->capacity));
		//检查是否扩容成功
		if (temp == NULL)
		{
			perror("realloc failed");//打印错误原因（如内存不足）
			exit(-1);//终止程序，避免后续非法操作
		}

		ps->a = temp;//更新数组指针
		ps->capacity *= 2;//更新容量值
	}
}

3.3 🔔test.c 顺序表功能测试

#include "SeqList.h"

int main()
{
	SL sl;
	//初始化顺序表：前面已经讲过，本文不做过多叙述
	SLInit(&sl);

	printf("******************** 头插操作 ********************\n");
	//头插
	SLPushFront(&sl, 5);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	//打印顺序表：前面已经讲过，本文不做过多叙述
	SLPrint(&sl);

	printf("******************** 头删操作 ********************\n");
	//头删
	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	//打印顺序表：前面已经讲过，本文不做过多叙述
	SLPrint(&sl);

	//销毁顺序表：前面已经讲过，本文不做过多叙述
	SLDestroy(&sl);
	return 0;
}

代码运行图：

---

📝全文总结

本文重点讲解顺序表的头插 、头删 两大基础操作，深入剖析了数据挪动的核心思路与代码实现。下期我们将继续讲解顺序表的查找某个值的下标 、在下标为pos位置插入x 、删除下标为pos位置的数据等操作，进一步完善顺序表的核心功能体系。

今天的干货分享到这里就结束啦！如果觉得文章还可以的话，希望能给个三连支持一下，聆风吟的主页还有很多有趣的文章，欢迎小伙伴们前去点评，您的支持就是作者前进的最大动力！