动态顺序表详解（结尾附全代码）

原创 已于 2025-09-08 14:21:24 修改 · 765 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言 #经验分享 #笔记

于 2025-09-07 21:17:08 首次发布

前言

顺序表分为动态与静态,动态常用(可以改变数组大小，更合理的利用空间),故此处详解动态顺序表

动态顺序表函数

动态顺序表分不开三个定义

1数组元素

2有效个数

3最大容纳个数

 

创建文件并做好开始准备代码

创建文件

注意Seqlist.h是顺序表结构,声明顺序表的方法

        Seqlist.c是实现顺序表的方法

        test.c是测试

开始准备代码,在头文件写入

#pragma once
#include <stdio.h>
#include <stdlib.h>
typedef int SLDateType; //此处进行重命名,是为了以后要进行更换数据类型便于更换
typedef struct SeqList
{
	SLDateType* arr;
	int size;
	int capacity;//空间大小
}SL;//此处再次进行重命名,是为了后续方便后续

 

 

顺序表的初始化

必须使用指针传参,若使用传值,则会出现未初始化

  1. 在test.c的代码  后续在test.c加上代码只需在SLTest01加上函数名(&s1)
  2. #include "Seqlist.h"
void SLTest01()
{
	SL s1;
	SLInit(&s1);//后续在test.c加上代码只需在SLTest01加上函数名(&s1)
}
int main()
{
	SLTest01();
	return 0;
}
  1. 在Seqlist.c的代码 
  2. #include "Seqlist.h"
void SLInit(SL*ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

     

  1. 在Seqlist.h的代码 
  2. #pragma once
#include <stdio.h>
#include <stdlib.h>
typedef int SLDateType; //此处进行重命名,是为了以后要进行更换数据类型便于更换
typedef struct SeqList
{
	SLDateType* arr;
	int size;
	int capacity;//空间大小
}SL;//此处再次进行重命名,是为了后续方便后续
//顺序表初始化
void SLInit(SL* ps);

     

顺序表的销毁

此处简单,先讲

 

Seqlist.h的代码

//本来应是顺序表的插入,但销毁简单,所以先讲
void SLDestory(SL* ps);

Seqlist.c的代码

(free只能释放动态开辟的空间,等下在后面开辟空间会讲解,不要认为此处错了)

void SLDestory(SL* ps)
{
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;

}

 

test.c

void SLTest01()
{
	SL s1;
	SLInit(&s1);//后续在test.c加上代码只需在SLTest01加上函数名(&s1)
	SLDestory(&s1);
}

后续Seqlist.h与Seqlist.c的代码加入形式不会与上面加入差距太大,都是函数名(接受的值)

故下面没有特殊情况(或编译代码时)不进行展示

顺序表的插入

共有三种插入方式

从尾部插入

即再数组的尾部插入一个数

直接给出结论,计算机扩大空间一般是2倍/3倍,此处以扩2倍为例

在顺序表插入之前,要先判断空间是否足够

如果不足,要开辟空间,这才能够进行插入,又因为不确定数据的大小,所以是动态开辟看,且使用realloc函数进行开辟

 

 

Seqlist.h的代码

//顺序表的尾插
void SLPushBack(SL* ps,SLDatetype x);

test.c的代码

表示尾插一个数字为4

//尾插
SLPushBack(&s1,4);

Seqlist.c的代码

 

判断空间是否足够和空间的开辟

void SLPushBack(SL* ps,SLDateType x)
{
	assert(ps);//先进行断言,防止NULL为空指针
	if (ps->size = ps->capacity)
	{
		int newcapacity = ps->capacity == NULL ? 4 : 2 * sizeof(ps->capacity);
		SLDateType* temp = (SLDateType*)realloc(ps->arr, 2 * newcapacity);
		if (temp == NULL)
		{
			perror("realloc");
			exit(1);
		}
	//空间申请成功
	ps->capacity = newcapacity;
	ps->arr = temp;
	}
}

当后面的两种尾插还要再写一次,过于繁琐,不如再创建一个判断空间是否足够和开辟空间的函数

此后,只需调用函数即可

void SLApply(SL* ps)
{
	if(ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == NULL ? 4 : 2 * sizeof(ps->capacity);
		SLDateType* temp = (SLDateType*)realloc(ps->arr, sizeof(SLDateType) * newcapacity);
		if (temp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		//空间申请成功
		ps->capacity = newcapacity;
		ps->arr = temp;
	}
}
void SLPushBack(SL* ps,SLDateType x)
{
	assert(ps);//先进行断言,防止NULL为空指针
	SLApply(ps);
}

最后再进行插入

注意,插入一个数据,有效数据size也要++

void SLPushBack(SL* ps,SLDateType x)
{
	assert(ps);//先进行断言,防止NULL为空指针
	SLApply(ps);
	ps->arr[ps->size++] = x;//注意,插入了一个数据,有效数组扩大一位,size要++
}

顺序表的打印

如果只是一次的插入,那我们可以清晰的了解过程

但若是以下情况甚至更多呢?

 

  1. include "Seqlist.h"
void SLTest01()
{
	SL s1;
	SLInit(&s1);//后续在test.c加上代码只需在SLTest01加上函数名(&s1)
	//尾插
	SLPushBack(&s1,1);
	SLPushBack(&s1,2);
	SLPushBack(&s1,3);
	SLPushBack(&s1,4);
	SLPushBack(&s1,5);
	SLDestory(&s1,6);
}
int main()
{
	SLTest01();
	return 0;
}
  2. 此时有两种解决方法

        1是Sleep函数

        2是每插入都打印顺序表

此处采用方法2

        则在test.c加入

此处使用的是顺序表的原始数据,所以传值即可

//尾插
SLPushBack(&s1,1);
SLprint(s1);
SLPushBack(&s1,2);
SLprint(s1);
SLPushBack(&s1,3);
SLprint(s1);
SLPushBack(&s1,4);
SLprint(s1);
SLPushBack(&s1,5);
SLprint(s1);
SLDestory(&s1,6);
SLprint(s1);

在Seqlist.c加入

void SLprint(SL ps)
{
	for (int i = 0; i < ps.size; i++)
		printf("%d ", ps.arr[i]);
    printf("\n");
}

 

接下来让我们运行代码,看看效果

结果如下,正确

从头部插入

从头部插入,经过画图知,即arr里的数据,全都要往后移一位,且是从最后一个数据开始移

实现方法有两种

  1. for循环
  2. 使用memmove函数

此处使用方法二

Seqlist.h的代码

//顺序表的头插
void SLPushFront(SL* ps, SLDateType x);

test.c的代码

SLPushFront(&s1, 6);
SLprint(s1);
SLPushFront(&s1, 7);
SLprint(s1);

 

seqlist.c的代码

void SLPushFront(SL* ps, SLDateType x)
{
	assert(ps);
	SLApply(ps);
	memmove(ps->arr + 1, ps->arr, sizeof(SLDateType) * ps->size);
	ps->arr[0] = x;//再进行插入
	++ps->size;//此时size依旧要++
}

 

最后结果,预取一样

从指定位置插入

指定位置插入,即比前面多了一个插入位置的下标,再分析其实就是将尾插的插入与头插的挪位置结合起来

同理:挪位置与头插一样有两种方式

此处依然使用memmove函数

Seqlist.h的代码

int num表示插入位置的下标

 

//顺序表的指定位置插入
void SLPushNoknow(SL* ps,int num,SLDateType x);

test.c的代码

SLPushNoknow(&s1, 4, 3);
SLprint(s1);
SLPushNoknow(&s1, 1, 1);
SLprint(s1);

Seqlist.c的代码

void SLPushNoknow(SL* ps, int num, SLDateType x)
{
	assert(ps);
	assert( num>=0 && num <= ps->size);//此处需判断插入位置是否在有效数字之间,此处num = size也可直接开辟空间
	SLApply(ps);
	memmove(ps->arr + num + 1, ps->arr + num, sizeof(SLDateType) * (ps->size - num ));
	ps->arr[num] = x;
	++ps->size;
}

插入全部完成,接下来进入删除

从尾部删除

本质就是有效数字size减少一个,无法读取即可

Seqlist.h的代码

//顺序表的尾删
void SLCleanBack(SL* ps);

test.c的代码

//顺序表的尾删
void SLCleanBack(SL* ps);

Seqlist.c

void SLCleanBack(SL* ps)
{
	assert(ps);
	assert(ps->size);//加入判断有效数字是否为0,不为0才可删
	//尾删其实就是有效数字少一个即可
	ps->size--;
}

从头部删除

头部删除与尾部删除大致一样,只是头部删除多了一个挪动数据的步骤

同样:此处依然可以采用for循环和memmove来挪动元素,

此处依旧采用memmove

SLeqlist.h

//顺序表的头删
void SLCleanFront(SL* ps);

test.c

SLCleanFront(&s1);
SLprint(s1);
SLCleanFront(&s1);
SLprint(s1);

Seqlist.c

void SLCleanFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	memmove(ps->arr, ps->arr + 1, sizeof(SLDateType) * ps->size - 1);
	ps->size--;
}

从指定位置删除

与前面添加一样,指定位置删除,其实也是结合了头删和尾删,一样需要判断输入的下标是否有效

Seqlist.h

//顺序表的指定删除
void SLCleanNoknow(SL* ps,int n);

test.c

//指定位置删除
SLCleanNoknow(&s1, 1);
SLprint(s1);
SLCleanNoknow(&s1, 0);
SLprint(s1);

Seqlist.c

void SLCleanNoknow(SL* ps, int n)
{
	assert(ps);
	assert(ps->size);
	assert(n >= 0 && n < ps -> size);
	memmove(ps->arr + n, ps->arr + n + 1, sizeof(SLDateType) * (ps->size - n - 1));
	ps->size--;
}

顺序表查找数据

在顺序表中查找一个数字,成功则返回该数字的下标,没有则返回:找不到

Seqlist.h

//顺序表的查找
int SLFind(SL* ps, int n);

test.c

//查找数据
int find = SLFind(&s1, 10);
if (find < 0)
	printf("找不到\n");
else
	printf("找到了,下标为%d\n", find);

Seqlist.c

/如果没有,返回值应该小于0,因为下标大于等于0

  
int SLFind(SL* ps, int n)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == n)
			return i;
	}
	return -1;//如果没有,返回值应该小于0,因为下标大于等于0
}

最后附上全部代码

Seqlist.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef int SLDateType; //此处进行重命名,是为了以后要进行更换数据类型便于更换
typedef struct SeqList
{
	SLDateType* arr;
	int size;
	int capacity;//空间大小
}SL;//此处再次进行重命名,是为了后续方便后续
//顺序表初始化
void SLInit(SL* ps);
//本来应是顺序表的插入,但销毁简单,所以先讲
void SLDestory(SL* ps);
//顺序表的尾插
void SLPushBack(SL* ps, SLDateType x);
//顺序表的头插
void SLPushFront(SL* ps, SLDateType x);
//顺序表的指定位置插入
void SLPushNoknow(SL* ps,int num,SLDateType x);
//顺序表的头删
void SLCleanFront(SL* ps);
//顺序表的尾删
void SLCleanBack(SL* ps);
//顺序表的指定删除
void SLCleanNoknow(SL* ps,int n);
//顺序表的查找
int SLFind(SL* ps, int n);

 

test.c

#include "Seqlist.h"
void SLTest01()
{
	//创建数据表
	SL s1;
	SLInit(&s1);//后续在test.c加上代码只需在SLTest01加上函数名(&s1)
	//尾插
	SLPushBack(&s1, 1);
	SLprint(s1);
	SLPushBack(&s1, 2);
	SLprint(s1);
	SLPushBack(&s1, 3);
	SLprint(s1);
	SLPushBack(&s1, 4);
	SLprint(s1);
	SLPushBack(&s1, 5);
	SLprint(s1);
	//头插
	SLPushFront(&s1, 6);
	SLprint(s1);
	SLPushFront(&s1, 7);
	SLprint(s1);
	SLPushNoknow(&s1, 3, 3);
	SLprint(s1);
	SLPushNoknow(&s1, 1, 1);
	//尾删
	SLCleanBack(&s1);
	SLprint(s1);
	SLCleanBack(&s1);
	SLprint(s1);
	//头删
	SLCleanFront(&s1);
	SLprint(s1);
	SLCleanFront(&s1);
	SLprint(s1);
	//指定位置删除
	SLCleanNoknow(&s1, 1);
	SLprint(s1);
	SLCleanNoknow(&s1, 0);
	SLprint(s1);
	//查找数据
	int find = SLFind(&s1, 10);
	if (find < 0)
		printf("找不到\n");
	else
		printf("找到了,下标为%d\n", find);
	//顺序表销毁
	SLDestory(&s1);
}
int main()
{
	SLTest01();
	return 0;
}

Seqlist.c

#include "Seqlist.h"
void SLInit(SL*ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
void SLDestory(SL* ps)
{
	if (ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
void SLprint(SL ps)
{
	for (int i = 0; i < ps.size; i++)
		printf("%d ", ps.arr[i]);
	printf("\n");
}
void SLApply(SL* ps)
{
	if(ps->size == ps->capacity)
	{
		int newcapacity = (ps->capacity == NULL ? 4 : 2 * ps->capacity);
		SLDateType* temp = (SLDateType*)realloc(ps->arr, sizeof(SLDateType) * newcapacity);
		if (temp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->capacity = newcapacity;
		ps->arr = temp;
	}
}
void SLPushBack(SL* ps,SLDateType x)
{
	
	assert(ps);//先进行断言,防止ps为空指针
	SLApply(ps);
	ps->arr[ps->size++] = x;//注意,插入了一个数据,有效数字扩大一位,size要++
}
void SLPushFront(SL* ps, SLDateType x)
{
	assert(ps);
	SLApply(ps);
	memmove(ps->arr + 1, ps->arr, sizeof(SLDateType) * ps->size);
	ps->arr[0] = x;//再进行插入
	++ps->size;//此时size依旧要++
}	
void SLPushNoknow(SL* ps, int num, SLDateType x)
{
	assert(ps);
	assert( num>=0 && num <= ps->size);//此处需判断插入位置是否在有效数字之间,此处num = size也可直接开辟空间
	SLApply(ps);
	memmove(ps->arr + num + 1, ps->arr + num, sizeof(SLDateType) * (ps->size - num ));
	ps->arr[num] = x;
	++ps->size;
}
void SLCleanBack(SL* ps)
{
	assert(ps);
	assert(ps->size);//加入判断有效数字是否为0,不为0才可删
	//尾删其实就是有效数字少一个即可
	ps->size--;
}
void SLCleanFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	memmove(ps->arr, ps->arr + 1, sizeof(SLDateType) * ps->size - 1);
	ps->size--;
}
void SLCleanNoknow(SL* ps, int n)
{
	assert(ps);
	assert(ps->size);
	assert(n >= 0 && n < ps -> size);
	memmove(ps->arr + n, ps->arr + n + 1, sizeof(SLDateType) * (ps->size - n - 1));
	ps->size--;
}
int SLFind(SL* ps, int n)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == n)
			return i;
	}
	return -1;//如果没有,返回值应该小于0,因为下标大于等于0
}

 

 

L070117
关注
数据结构：顺序表详解
Zhenyu_Coder的博客
07-30 6705
顺序表作为一种基本的数据结构，在许多应用场景中具有重要的意义和作用，可以提高数据的访问和操作效率，简化算法设计，提高内存利用率。本篇博客将向你详细介绍其模拟过程及全代码
【数据结构】顺序表详解（附leetcode练习题）
fighting小泽的博客
04-19 1139
线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
最全动态规划题型详解
阿华的保温杯的博客
11-17 8065
通俗的讲动态规划（dp）的核心就是记住已经解决过子问题的解，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。dp常常适用于有重叠子问题和最优子结构性质的问题,动态规划方法所消耗的时间往往远小于朴素解法。
【数据结构】顺序表和链表的区别和联系（详解）
铭哥不写bug的博客
02-22 1992
本文介绍了顺序表和链表相关的一些区别和联系。如果我的博客对你有所帮助记得三连支持一下，感谢大家的支持！
C语言链表详解
qq_28576837的博客
06-02 5226
C语言链表详解
C语言之 数据结构入门——顺序表的构造
tq02的博客
12-27 3704
顺序表的删、插、增、查、扩等详解，且结尾附带完整代码
数据结构 严薇敏 顺序表的实现(增 删 改)及其使用方法详解
qq_50119037的博客
03-13 3229
1.线性表 概念：线性表是n个具有相同特征性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，每个元素都有唯一的前去和唯一的后继，前一个元素没有前驱只有后继，最后一个元素没有后继只有前驱，常见的线性表：顺序表、链表、栈、队列、字符串。 数组不等于线性表，数组只是把元素存储起来了！可以增加一些增删改的方法！ 2.顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1...
【数据结构】顺序表、单链表的 比较+总结
It’s All Uphill From Here
09-17 1789
（优缺点文字部分转自： http://blog.csdn.net/zhang_minli/article/details/50489996）顺序表和链表de优缺点顺序表的优点方法简单，各种高级语言中都有数组，容易实现。 不用为表示结点间的逻辑关系而增加额外的存储开销（链表要增加额外的指针域）。 顺序表具有按元素序号随机访问的特点。缺点 在顺序表中做插入删除操作时，平均移动大约表中一般的元素，因
【数据结构】链表（LinkedList）详解
flmz_Kk的博客
07-15 8196
使用Java实现链表的创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作
【JAVA】双向链表详解
weixin_74999790的博客
06-04 3856
LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。每个数据节点都有两个指针，指向前驱和后继，所以，双向链表中的任意一个节点开始，都可以十分方便找到前驱节点和后继节点。
java LinkedList类详解及实例代码
08-31
2. **有序性**：LinkedList按照插入顺序维护元素的顺序，可以通过索引访问元素，与ArrayList类似。 3. **效率**：在插入和删除元素时，LinkedList通常比ArrayList更快，因为不需要移动其他元素。但在随机访问元素时...
已知有两个按元素值递增有序的顺序表A和B，设计一个算法将表A和表B的全部元素归并为一个按元素值递增有序的顺序表C。
03-27
根据给定的文件信息，本篇文章将详细解析如何设计一种算法来合并两个递增有序的顺序表（数组）A和B，并确保合并后的结果也是一个递增有序的顺序表C。 ### 一、问题背景 在计算机科学中，数据结构与算法是极其重要...
【Linux】进程间通信——管道（1w5字图文详解，附代码和运行动图）
Eristic0618的博客
09-03 3996
本篇文章围绕Linux中的管道展开讲解，包含进程间通信的概念和手段、匿名管道的概念、用法、特征、读写规则、应用场景和命名管道的概念、创建方式、用法和读写规则等内容
Redis之核心数据结构浅析
qq_44784918的博客
09-05 993
Redis基础命令与数据结构摘要 Redis支持多种数据结构，命令不区分大小写但key区分： String：单值操作(set/get)、多值(mset/mget)、分布式锁(setnx/expire)、计数器(incr) Hash：存储对象(hset/hgetall)，适合购物车场景，节省空间但无法field级过期 List：双端队列(lpush/rpop)，可用于消息队列 Set：去重集合(sadd/smembers)，适合抽奖、点赞等场景 Zset：有序集合(zadd/zrange)，带score排序，
数据结构之二叉树（2）
2401_86945837的博客
09-07 595
int size;}Hp;size表示有效个数capacity表示可用容量。
【数据结构基础习题】-1- 数据结构基本操作
最新发布
2401_83117850的博客
09-07 840
int *data;// 存储数据的数组int front;// 队头指针int rear;// 队尾指针// 数组容量int size;// 队列中元素个数。
嵌入式中关于数据结构的简单认识
嵌入式技术开发
09-07 18
摘要：数据结构是计算机存储和组织数据的方式，分为逻辑结构和物理结构。逻辑结构包括线性、非线性（树形、图形）和集合结构；物理结构包含顺序、链式、索引和散列存储。算法是解决问题的步骤，具有有穷性、确定性、可行性等特征。评估算法的优劣主要看时间复杂度和空间复杂度：时间复杂度反映语句执行次数（如O(n)），空间复杂度衡量内存占用。两者常相互制约，需根据需求选择平衡。好的算法应兼顾效率、可读性和可维护性。
数据结构之双向链表
2401_86945837的博客
09-05 374
链表的结构有很多。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表。
数据结构与排序算法：从理论到场景，解锁高效数据处理的核心逻辑
nb12138666的博客
09-04 789
摘要 本文探讨数据结构与排序算法的协同关系，强调不同数据结构适配不同排序算法的核心逻辑。通过6个典型业务场景（如学生成绩排名、实时商品列表、海量日志排序等），分析如何根据数据结构特性（数组随机访问、链表插入高效）选择最优排序算法（快速排序、插入排序、归并排序等）。案例包含数据结构选择理由、算法效率对比及关键代码实现，帮助开发者在实际业务中构建高效数据处理方案。例如：数组+快排适合固定数据集排序，链表+插入排序适合动态更新场景，归并排序则保障海量数据的稳定排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值