数据结构——顺序表

原创 已于 2025-11-14 00:59:39 修改 · 1.3k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言

于 2025-11-14 00:47:03 首次发布

目录

一、概念和结构

1. 线性表

2.顺序表的概念

3.顺序表的结构

二、分类

1.静态顺序表：

2.动态顺序表：

三、顺序表的实现

1.定义顺序表：

2.初始化：

3.打印数据：

4.插入数据：

1）尾插（初始版本和简洁版本）

2）头插

5.删除数据

1）尾删

2）头删

6.指定位置插入/删除

1）在指定位置之前插入数据

2）删除指定位置的数据

7.查找数据

8.销毁函数

四、博主手记

五、完整版代码分享

Seqlist.h

Seqlist.c

test.c

前言：

经过了上一节对数据结构和算法复杂度的认识，我们现在进入到了数据结构正式的学习环节，前方迎接我们的是更深层次的学习。这一篇文章给大家分享一下顺序表的内容，有基础知识还有代码实现哦，最后还有题目等着我们。

一、概念和结构

1. 线性表

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

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

2.顺序表的概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。

顺序表就是  数组+增加数据+删除数据+修改数据+查找数据+......

顺序表的底层是数组，顺序表是用数组实现的。

3.顺序表的结构

逻辑结构：线性

物理结构：线性

二、分类

顺序表分为静态顺序表和动态顺序表，下面用代码来分别说明一下静态顺序表和动态顺序表的不同之处：

1.静态顺序表：

//概念：使⽤定⻓数组存储元素
typedef int SLDateType
#define N 7
typedef struct SeqList
{
    SLDateType a[n];  //定长数组
    int size;         //有效数据个数
}
//静态顺序表缺陷：空间给少了不够⽤，给多了造成空间浪费

2.动态顺序表：

//动态顺序表--按需申请
typedef struct SeqList
{
    SLDateType* a;  
    int size;      //有效数据个数
    int capacity;  //空间容量
}

三、顺序表的实现

顺序表的实现可以分成三个函数来实现：

SeqList.h ：定义结构，声明函数（头文件）

SeqList.c ：定义函数

test.c        ：测试功能

下面我给大家分功能来实现线性表

1.定义顺序表：

//定义动态顺序表的结构
typedef int SLTDateType;//用别名方便后续更改顺序表的类型
typedef struct Seqlist {
	SLTDateType* arr; //存储数据的数组
	int size; //有效数据个数
	int capacity; //空间大小
}SL;

//函数声明
void Slinit(SL* ps);

定义顺序表部分写在SeqList.h部分

2.初始化：

初始化和后面的函数功能都写在SeqList.c上，但需要在SeqList.h上面声明。

//初始化
void Slinit(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

写完功能后再test.c部分测试是否成功，如右图所示

#include"Seqlist.h"

void test01()
{
	SL s1;
	Slinit(&s1);
}

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

3.打印数据：

//打印函数
void Slprint(SL* ps)
{
	for (int i = 0;i < ps->size;i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

4.插入数据：

1）尾插（初始版本和简洁版本）

//尾插法
void SlPushBack(SL* ps, SLTDateType x)
{
	assert(ps);
	if (ps->size == ps->capacity)
    {
	    int newCapacity = ps->capacity = 0 ? 4 : 2 * ps->capacity;
	    SLTDateType* temp = (SLTDateType*)realloc(ps->arr, newCapacity * sizeof(SLTDateType));
	    if (temp == NULL)
	    {
		    perror("realloc");
		    exit(1);
	    }
	    ps->arr = temp;
	    ps->capacity = newCapacity;
    }
	ps->arr[ps->size++] = x;
}

在写尾插操作过程中发现了其中的增容操作后续仍需要使用，所以，我们可以把增容这一部分给分离出来，单独设置一个函数，方便后续操作中的扩容操作

增容函数：

//扩容
void SlCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity = 0 ? 4 : 2 * ps->capacity;
		SLTDateType* temp = (SLTDateType * )realloc(ps->arr, newCapacity * sizeof(SLTDateType));
		if (temp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = temp;
		ps->capacity = newCapacity;
	}
}

这样，尾插函数就会简洁许多：

//尾插法
void SlPushBack(SL* ps, SLTDateType x)
{
	assert(ps);
	SlCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

2）头插

//头插法
void SlPushFront(SL* ps, SLTDateType x)
{
	assert(ps);
	SlCheckCapacity(ps);
	for (int i = ps->size;i > 0;i--)
	{
		ps->arr[i - 1] = ps->arr[i];
	}
	ps->arr[0] = x;
	ps->size++;
}

5.删除数据

1）尾删

尾删就比较简单了，只需要将size前移一位，size后面的数据就不是有效数据了，相当于被删除。

assert(ps && ps->size);除了需要断言ps不为空指针情况外，还需要断言一下顺序表不能为空，就是ps->size!=0，也就是assert（ps->size）。

//尾删法
void SlDelBack(SL* ps)
{
	assert(ps && ps->size);
	ps->size--;
}

2）头删

头删比尾删多了一步需要将后面的数据全部向前挪动一位

//头删法
void SlDelFront(SL* ps)
{
	assert(ps && ps->size);
	for (int i = 0;i < ps->size-1;i++)
	{
		ps->arr[i + 1] = ps->arr[i];
	}
	ps->size--;
}

6.指定位置插入/删除

1）在指定位置之前插入数据

//在指定位置之前插入数据
void Slinsert(SL* ps, int pos, SLTDateType x)
{
	assert(ps && pos >= 0 && pos < ps->size);
	for (int i = ps->size;i > pos;i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

2）删除指定位置的数据

//删除指定位置的数据
void Slerase(SL* ps, int pos)
{
	assert(ps && ps->size);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos;i < ps->size - 1;i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

7.查找数据

//查找
int SLFind(SL* ps, SLTDateType x)
{
	assert(ps);
	for (int i = 0;i < ps->size;i++)
	{
		if (ps->arr[i] == x)
		{
			return i;//找到了
		}	
	}
	return -1;//未找到
}

8.销毁函数

//销毁函数
void Sldestroy(SL* ps)
{
	if (ps->arr != NULL)
		free(ps->arr);
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

四、博主手记

字迹不是很好，大家多见谅QAQ

五、完整版代码分享

Seqlist.h

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

//定义动态顺序表的结构
typedef int SLTDateType;//用别名方便后续更改顺序表的类型
typedef struct Seqlist {
	SLTDateType* arr; //存储数据的数组
	int size; //有效数据个数
	int capacity; //空间大小
}SL;

//函数声明
//初始化
void Slinit(SL* ps);
//打印函数
void Slprint(SL* ps);
//销毁函数
void Sldestroy(SL* ps);
//扩容
void SlCheckCapacity(SL* ps);
//尾插法
void SlPushBack(SL* ps, SLTDateType x);
//头插法
void SlPushFront(SL* ps, SLTDateType x);
//尾删法
void SlDelBack(SL* ps);
//头删法
void SlDelFront(SL* ps);
//在指定位置之前插入数据
void Slinsert(SL* ps, int pos, SLTDateType x);
//删除指定位置的数据
void Slerase(SL* ps, int pos);
//查找
int SLFind(SL* ps, SLTDateType x);

Seqlist.c

#define _CRT_SECURE_NO_WARNINGS
#include"Seqlist.h"

//初始化
void Slinit(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}


//打印函数
void Slprint(SL* ps)
{
	for (int i = 0;i < ps->size;i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

//扩容
void SlCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity = 0 ? 4 : 2 * ps->capacity;
		SLTDateType* temp = (SLTDateType * )realloc(ps->arr, newCapacity * sizeof(SLTDateType));
		if (temp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = temp;
		ps->capacity = newCapacity;
	}
}

//尾插法
void SlPushBack(SL* ps, SLTDateType x)
{
	assert(ps);
	SlCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

//头插法
void SlPushFront(SL* ps, SLTDateType x)
{
	assert(ps);
	SlCheckCapacity(ps);
	for (int i = ps->size;i > 0;i--)
	{
		ps->arr[i - 1] = ps->arr[i];
	}
	ps->arr[0] = x;
	ps->size++;
}

//尾删法
void SlDelBack(SL* ps)
{
	assert(ps && ps->size);
	ps->size--;
}

//头删法
void SlDelFront(SL* ps)
{
	assert(ps && ps->size);
	for (int i = 0;i < ps->size-1;i++)
	{
		ps->arr[i + 1] = ps->arr[i];
	}
	ps->size--;
}

//在指定位置之前插入数据
void Slinsert(SL* ps, int pos, SLTDateType x)
{
	assert(ps && pos >= 0 && pos < ps->size);
	for (int i = ps->size;i > pos;i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

//删除指定位置的数据
void Slerase(SL* ps, int pos)
{
	assert(ps && ps->size);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos;i < ps->size - 1;i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

//查找
int SLFind(SL* ps, SLTDateType x)
{
	assert(ps);
	for (int i = 0;i < ps->size;i++)
	{
		if (ps->arr[i] == x)
		{
			return i;//找到了
		}	
	}
	return -1;//未找到
}

//销毁函数
void Sldestroy(SL* ps)
{
	if (ps->arr != NULL)
		free(ps->arr);
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS
#include"Seqlist.h"

void test01()
{
	SL sl;
	SLInit(&sl);
	//具备了一个空的顺序表
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);
	//SLPushFront(&sl, 1);
	//SLPushFront(&sl, 2);//2 1
	//SLPushFront(&sl, 3);//3 2 1
	//SLPushFront(&sl, 4);//4 3 2 1
	//SLPopBack(&sl);
	//SLPrint(&sl);//1 2 3
	//SLPopBack(&sl);
	//SLPrint(&sl);//1 2 
	//SLPopBack(&sl);
	//SLPrint(&sl);//1 
	//SLPopBack(&sl);
	//SLPrint(&sl);//
	//SLPopBack(&sl);

	////头删
	//SLPopFront(&sl);
	//SLPrint(&sl);
	//SLPopFront(&sl);
	//SLPrint(&sl);
	//SLPopFront(&sl);
	//SLPrint(&sl);
	//SLPopFront(&sl);
	//SLPrint(&sl);

	//SLPopFront(&sl);

	//测试查找
	int pos = SLFind(&sl, 4);
	//if (pos < 0)
	//{
	//	printf("未找到！\n");
	//}
	//else {
	//	printf("找到了！\n");
	//}
	//SLInsert(&sl, pos, 100);
	//SLPrint(&sl);
	//SLInsert(&sl, pos, 200);
	//SLPrint(&sl);
	//SLInsert(&sl, pos, 300);
	//SLPrint(&sl);
	//SLInsert(&sl, pos, 400);
	//SLPrint(&sl);
	SLErase(&sl, pos);
	SLPrint(&sl);
	SLDestroy(&sl);
}

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

结语：
上面就是我这篇文章的全部内容啦，如果有哪里不妥非常欢迎大家指点！欢迎大家在评论区留言！

下一篇文章我会分享顺序表的练习题哦，欢迎大家关注！

数据结构——顺序表的合并
qq_45966201的博客
02-02 1万+
数据结构——顺序表的合并 具体要求：写一个函数，其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体，只有先定义了顺序表的结构体类型，才可以继续进行下一步操作 #define maxsize 100 typedef struct { int elem[maxsize];//线性表元素 int last;//线性表长度 }SeqList; 二、顺序表的操作 1.生成顺序表 在有了顺序表的结构之后，
初识数据结构——顺序表
2403_88122966的博客
02-27 1231
简单介绍数据结构的概念，讲解数据结构的其中一种——顺序表
数据结构——顺序表（SqList）
m0_73513334的博客
06-23 1365
【代码】数据结构——顺序表（SqList）
数据结构——顺序表详解
weixin_51785373的博客
10-05 8677
定义顺序表是一种线性表的存储结构，它用一组地址连续的存储单位依次存储线性表中的数据元素。从而使得逻辑上相邻的两个元素在物理位置上也相邻。顺序表具有动态分配空间、支持随机访问和顺序访问,逻辑顺序与物理顺序一致。每个元素可以都有唯一的位置，可以通过索引直接访问元素。元素可以是任意类型，包括基本数据类型、结构体等。
数据结构——顺序表（定义、实现）
weixin_62677583的博客
12-19 3397
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
C++数据结构——顺序表——数值统计
qq_48335434的博客
04-05 529
顺序表
数据结构——顺序表（C语言编写）
新手小白
09-17 8736
数据结构，顺序表应用 插入、删除、合并...
数据结构 ——顺序表【c语言版】
clear-ninghongkang的博客
11-19 6321
线性表：具有相同特性的数据元素（既同类型数据）的一个有限序列. 注：同一线性表中的元素必定具有相同特性 线性表的特性：1.有穷性 2.一致性 3.序列性 线性表的最本质特征：有唯一的前驱和后继 线性表的顺序存储结构———顺序表 顺序存储结构——逻辑上相邻的元素，在物理上也相邻 在c语言中，顺序表通常用数组来存储，这与python中的列表不同，数组是给定长度的，数组中元素的地址也是相邻的，且数组中的元素类型一定要相同,而列表list是的长度理论上是可以无限添加的，(因为pyt...
数据结构——顺序表的基本操作
2401_83697427的博客
05-18 1501
在表L中查找具有给定关键字值的元素。获取表L中第i个位置的元素的值。2.总循环次数——n+1种情况，每种情况的循环次数相加总和。ListDelete(&L,i,&e)：删除表L中。ListInsert(&L,i,e)：在表L中的。覆盖——j从i到L.length-1循环，保证。覆盖——j从L.length到i循环，保证。表L中第i个位置的元素，保证在删除元素后该。元素，保证在上一次赋值之后，下一次赋值时。O(1)——顺序表的各个数据元素。2.将L.data[j]该元素。分析：删除数组中的元素c，元素。
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
python数据结构——顺序表
fyire的博客
08-15 826
1. 顺序表的定义 数据元素连续存储，并且每个元素的存储空间大小相同，元素下标是逻辑地址，元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定。 2. 顺序表的优点 由于元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定，因此要访问一个元素不用做遍历操作，只需给定逻辑地址就可是实现访问。 计算物理地址的公式如下： 其中表示逻辑地址，表示第 给元素，表示存储区的起始地址， 表示每个元素存...
2025年CSP-X初赛真题及题解（辽宁）：初赛编程题目T3：稳定插入排序
王老师青少年编程
11-21 664
2025年CSP-X初赛真题及题解（辽宁）：初赛编程题目T3：稳定插入排序
数据结构之排序-选择排序&交换排序
最新发布
2501_91275995的博客
11-21 786
本文主要讲解了选择排序中的直接选择排序和交换排序中的快速排序算法。直接选择排序通过每次遍历找出最小和最大值进行交换，但需要注意当最大值在数组开头时的特殊情况处理。快速排序采用递归思想，通过基准值将数组分为左右两部分，其中重点讲解了hoare版本和lomuto前后指针版本的实现，并提出了三数取中和小区间优化等改进方法。此外还介绍了利用栈实现非递归版本的快速排序，避免了递归可能导致的栈溢出问题。文章通过代码示例和图示详细说明了各算法的实现逻辑和优化思路，为后续学习归并排序打下基础。
redis GEO数据结构、实现附近商铺功能
m0_53881899的博客
11-20 242
redis GEO数据结构、实现附近商铺功能
C++实现数据结构——前言
buyue
11-21 132
C++泛型编程是通过模板实现代码与具体数据类型无关的编程范式，核心是函数模板和类模板，支持多种数据类型的代码复用。我们将使用泛型编程来实现各种数据结构。
【C++ 数据结构】二叉搜索树：原理、实现与核心操作全解析
kongsicheng10的博客
11-21 1123
本文系统介绍了二叉搜索树(BST)的核心概念和C++实现。主要内容包括：1）BST的定义与特性，重点分析了其排序规则和中序遍历有序性；2）完整代码实现，涵盖插入、查找、删除等核心操作；3）详细解析删除操作的三种情况处理，特别是左右子树均存在时的替换法；4）代码优化建议和常见错误分析；5）总结BST优缺点并指出进阶学习方向（AVL树、红黑树等）。文章通过清晰的代码示例和深入解析，帮助读者掌握BST的实现原理和应用场景，为学习更复杂的树结构奠定基础。
【数据结构】【单链表】【循环链表】【双链表】【二叉树】【图】
奔跑吧 android 的博客
11-21 129
单链表、循环链表和双链表的比较 单链表：每个节点只存储下一个节点的指针，插入删除快但查找慢，适合简单线性数据存储。 循环链表：尾节点指向头节点形成环状结构，适合轮询调度等循环场景，需注意避免死循环。 双链表：每个节点存储前后节点指针，支持双向遍历，删除操作更方便，但占用更多内存空间。 三种链表各有特点：单链表简单高效，循环链表适合环形数据处理，双链表提供双向访问能力。
湖南大学数据结构实验1——顺序表项目源码解析
资源摘要信息:"湖南大学数据结构实验1顺序表.zip" 从标题、描述、标签和压缩包内的文件列表来看，这个压缩包包含的是关于数据结构课程的实验材料，特别关注于顺序表的实现和操作。顺序表是一种线性表的存储结构，其...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值