数据结构——顺序表(附图文讲解|超详细)

最新推荐文章于 2026-08-19 18:46:54 发布
原创 最新推荐文章于 2026-08-19 18:46:54 发布 · 824 阅读 · 21 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

文章目录

一、前言

在数据结构中的学习中，线性表是最基础的结构，而顺序表是根据线性表的顺序存储实现的，也是我们第一个接触到的数据结构。

这篇博客我将从0到1详细讲解顺序表，保证看完就懂。

二、顺序表

2.1 概念

线性表

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

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

顺序表

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

总结：

线性表顺序表
逻辑结构一定是线性的一定是线性的
物理结构不一定是线性的一定是线性的

在这里插入图片描述

在这里插入图片描述

顺序表和数组的关系：

在这里插入图片描述

2.2 分类

顺序表分为静态顺序表和动态顺序表

2.2.1 静态顺序表

概念：使⽤定⻓数组存储元素

在这里插入图片描述

静态顺序表缺陷：空间给少了不够⽤，给多了造成空间浪费

2.2.2 动态顺序表

在这里插入图片描述

动态顺序表的结构更加灵活, 可以对结构进行增删查改等操作

2.3 动态顺序表的实现

2.3.1 准备工作

先创建三个文件

在这里插入图片描述

 解释这三个文件的作用
 1、头文件SeqList.h是来声明接口函数，定义顺序表，将几个公共用到的库函数集合起来
 2、源文件SeqList.c是用来具体实现接口
 3、源文件test.c用于接口的测试工作 ，即具体的使用场景
2.3.2 顺序表的功能接口
1. 创建一个顺序表
//动态顺序表
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int capacity; //有效数据个数
	int size; //空间容量
}SL;
2. 顺序表的初始化
//初始化
void SLInit(SL* ps)
{
    assert(ps);
    ps->arr = NULL;
    ps->size = 0;
    ps->capacity = 0;
}
3. 顺序表的销毁
//销毁
void SLDestroy(SL* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
4. 顺序表的打印
//打印
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
5. 顺序表的增容

增容一般成倍数增加，一般是2、3倍，推荐2倍增容

若每次只增加一个空间，会存在频繁增容，程序执行效率低下

若每次增加的空间比较大，会存在空间的浪费

//增容
void SLCheckCapacity(SL* ps)
{
    //当有效数据个数 == 空间容量时，说明空间满了，需要增容
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		//增容
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
6. 顺序表的增加功能接口

6.1 尾插接口

直接加在顺序表的最后面

在这里插入图片描述

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//判断空间是否足够，不够就增容
	SLCheckCapacity(ps);
	//空间足够的情况下
	ps->arr[ps->size++] = x;
}

6.2 头插接口

先将顺序表中的所有数据向后挪动一位，再将要增加的数据加在顺序表的最前面

在这里插入图片描述

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//判断空间是否足够，不够就增容
	SLCheckCapacity(ps);
	//将顺序表中所有数据向后挪动一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//后移
	}
    //将要增加的数据加在最前面
	ps->arr[0] = x;
	++ps->size;
}

6.3 指定位置插入接口

先将指定的位置及之后的数据整体向后挪动一位，再将要增加的数据加在指定的位置

在这里插入图片描述

//pos位置插⼊数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);
	//pos及之后的数据整体向后挪动一位
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	++ps->size;
}
7. 顺序表的删除功能接口

7.1 尾删接口

直接将最后一个数据删除

在这里插入图片描述

//尾删
void SLPopBack(SL* ps)
{
	//ps->size：顺序表为空
	assert(ps && ps->size);
	--ps->size;
}

7.2 头删接口

从第2个数据开始向前移动一位，是第1个数据被覆盖掉，只有一个数据的话直接删除这一个数

在这里插入图片描述

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

7.3 指定位置删除接口

指定位置之后的数据整体向前挪动一位

在这里插入图片描述

// 删除POS位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	//pos之后的数据整体向前挪动一位
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	--ps->size;
}
8. 顺序表的查找实现接口

一个一个进行比对

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

三、总代码

SeqList.h

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

//定义动态顺序表的结构
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int size;      //有效数据个数
	int capacity;  //空间容量
}SL;

//打印
void SLPrint(SL* ps);
//初始化
void SLInit(SL* ps);
//销毁
void SLDestroy(SL* ps);

//尾插
void SLPushBack(SL* ps, SLDataType x);
//头插
void SLPushFront(SL* ps, SLDataType x);
//尾删
void SLPopBack(SL* ps);
//头删
void SLPopFront(SL* ps);

//指定位置插⼊数据
void SLInsert(SL* ps, int pos, SLDataType x);
// 删除POS位置的数据
void SLErase(SL* ps, int pos);
//查找
int SLFind(SL* ps, SLDataType x);

SeqList.c

#include"SeqList.h"

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

void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		//增容
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//判断空间是否足够,不够的话增容
	SLCheckCapacity(ps);
	//空间足够的情况下
	ps->arr[ps->size++] = x;
}

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps != NULL);
	//判断空间是否足够,不够的话增容
	SLCheckCapacity(ps);
	//将顺序表中所有数据向后挪动一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//后移
	}
	ps->arr[0] = x;
	++ps->size;
}

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

//打印
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
//头删
void SLPopFront(SL* ps)
{
	assert(ps && ps->size);
	for (int i = 0; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	--ps->size;
}

//指定位置之前插⼊数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);
	//pos及之后的数据整体向后挪动一位
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	++ps->size;
}
// 删除POS位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	//pos之后的数据整体向前挪动一位
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	--ps->size;
}
//查找
int SLFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			//找到了
			return i;
		}
	}
	//未找到
	return -1;
}
//销毁
void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

test.c

#include"SeqList.h"
void slTest01()
{
	SL sl; 
	SLInit(&sl); 
 
	//尾插
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4); // ctrl + d == ctrl + c + v
	printf("尾插: ");
	SLPrint(&sl);
 
	// 头插
	SLPushFront(&sl, 10);
	printf("头插: ");
	SLPrint(&sl);
 
	// 尾删
	SLPopBack(&sl);
	printf("尾删: ");
	SLPrint(&sl);
 
	// 头删
	SLPopFront(&sl);
	printf("头删: ");
	SLPrint(&sl);
 
	// 指定位置插入
	SLInsert(&sl, 1, 15);
	printf("指定插入: ");
	SLPrint(&sl);
 
	SLErase(&sl, 1);
	printf("指定删除: ");
	SLPrint(&sl);
}
int main()
{
	slTest01(); //测试函数
	return 0;
}
标签
#数据结构 #c语言 #算法
中级软考（软件攻城狮）第3章知识点——数据结构与数据运算（线性结构+非线性结构）
睡不醒的每天
08-18 28
本文系统梳理了数据结构中的线性与非线性结构。线性部分详细介绍了线性表（顺序/链式存储及时间复杂度对比）、栈（后进先出特性及应用）、队列（循环队列与双端队列）以及串（空串与子串概念）。非线性部分涵盖数组、矩阵、广义表，重点解析了树结构（二叉树性质、存储方式及遍历方法），并深入讲解了最优二叉树（哈夫曼树）的构建原理与编码应用。全文通过图示对比和实例说明，清晰呈现了各类数据结构的特点、存储方式及典型应用场景。
【数据结构初阶】：动态顺序表的功能实现（用C语言实现，附图分析）
平凡的指针的博客
10-16 1434
文章目录一、动态版本顺序表二、动态顺序表的实现思路三、动态顺序表内存布局图四、初始化顺序表和内存释放五、顺序表接口实现：1.尾部插入数据2.头部插入数据3.尾部删除数据4.头部删除数据5.显示数据6.查找数据7.在某个位置插入数据8.在某个位置删除数据六、对头插 尾插 头删 尾删 的改造七、总结 一、动态版本顺序表 在实现顺序表之前，我们要知道顺序表按照能不能扩容可以分为两种版本，静态版本和动态版本。 静态版本就是把内容存到数组中，一旦数组在内存栈上开辟了，当数据存满的时候就不能再继续存储了。所以针对这个.
数据结构之线性表
m0_47104421的博客
12-28 330
线性表ADT 取自严蔚敏版数据结构 ADT List{ 数据对象：D = {ai | ai ∈ ElemSet, i = 1,2,…, n, n>= 0} 数据关系：R1 = {<ai-1, ai> | ai-1, ai∈D, i = 2, …, n} 基本操作：InitList(&L)      Length(L)      LocateElem(L, e)      GetElem(L,i)      ListInsert(&L, i, e)      LIstDe
数据结构之顺序表和链表的比较（详解，附图）
Easenyang的博客
05-22 6018
两大线性表的区别
Sequential And Linked Lists - 顺序表 和 链表 - 顺序表部分 - java
2401_84048034的博客
05-13 923
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
GXF 3.2.0 to 4.0 CUDA 12 路径 API 与数据结构增量分析
eloudy的专栏
08-18 241
分析范围：以仓库中与分支对比为基础，聚焦）可用的公共 API 与数据结构变化。由于 GXF 核心头文件在各 CUDA 版本间共享，下列新增/修改的接口在 CUDA 12 构建上同样生效。对比链接：https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_nitros/compare/release-3.2…release-4.0。
快速学会数据结构中的链式队列与循环队列
2401_82745609的博客
08-17 532
一种允许从一端插入数据，另外一端删除数据的线性存储结构称为队列。把数据插入的这端称为队列的队尾， 数据删除这端称为队列的队头。插入操作称为入队；删除操作称为出队。先进先出、后进后出数据缓存。
数据结构 --- 二叉树&哈希表
最新发布
2401_86288082的博客
08-19 690
本篇数据结构学习笔记分为二叉树、哈希表两大板块。二叉树部分讲解树形基础概念、链式存储方式、前 / 中 / 后序遍历算法，介绍带占位符字符串递归创建二叉树的方法，配套结点计数、深度计算、内存销毁等递归代码实现，补充二叉树核心数学性质。哈希表板块梳理哈希函数、哈希冲突概念，对比开放定址法、链地址法两种冲突解决方案，分析操作的时间复杂度。最后完整给出拉链哈希表五大功能模块的 C 语言实现代码，讲解插入、查找、打印、销毁的执行流程，同时点明现有代码的缺陷与优化方向。
数据结构：双向链表 内核链表 链式队列
yxg0505的博客
08-15 438
本文介绍了链表操作中的几种常用算法技巧。主要包括：1. 快慢指针法（查找中间节点和倒数第k个节点）；2. 链表基本操作（查找、删除特定节点、逆序、排序）；3. 环形链表处理（判断是否有环、获取环入口）；4. 双向链表操作（头插尾插、头删尾删）；5. 内核链表与普通链表的区别；6. 队列的基本概念（FIFO特性）及其应用。这些算法涵盖了链表操作的核心技术，包括单/双向链表处理、环形链表检测以及队列实现等常见数据结构问题。
【数据结构】C语言实现链式二叉树
Jupiter1007的博客
08-18 323
本文系统介绍了链式二叉树的实现与操作，包括节点创建、遍历算法（先序、中序、后序、层序）、节点统计（总数、叶子节点、左右子节点）、高度计算、层级节点查询、节点查找、完全二叉树判断、二叉树翻转和销毁等16个核心功能。重点阐述了递归思想在二叉树操作中的应用，并展示了队列在层序遍历和完全二叉树判断中的关键作用。所有操作均通过C语言实现，提供了完整的代码示例，为理解和实现链式二叉树数据结构提供了全面参考。
【数据结构】平衡二叉树（AVL）与哈夫曼树
bianyuan172的博客
08-16 270
本文系统讲解了AVL树和哈夫曼树两大高频考点。AVL树通过平衡因子（-1/0/1）实现自平衡，详细解析了LL、RR、LR、RL四种旋转操作及其应用场景，确保查找效率维持在O(log n)。哈夫曼树部分阐述了其构造方法（每次合并最小权值节点）和WPL计算，并给出哈夫曼编码的生成规则。文章配备典型例题和记忆口诀，强调AVL旋转与哈夫曼WPL计算是重点题型，建议重点掌握平衡因子判断与旋转操作，以及哈夫曼树的构建流程。
408 数据结构｜完全二叉树两道典型题：第 6 层叶结点数与叶结点总数
2301_82049134的博客
08-16 154
除最后一层外：全部满最后一层：允许不满，但必须从左到右连续排列○/ \○ ○/ \ / \○ ○ ○ ○/ \ /○ ○ ○尽量让这一层直接成为最后一层= 39总结点数 = 2n0 - 1或总结点数 = 2n0最少 = 2n0 - 1最多 = 2n0n0 = 124最少 = 2×124 - 1 = 247最多 = 2×124 = 248。
Java 数据结构详解：从栈、队列、链表到红黑树、B-Tree 与位图
qq_29029209的博客
08-14 825
本文摘要：数据结构解决的是如何高效组织数据以优化常见操作的问题。文章以Java为例，讲解了8种核心数据结构（栈、队列、链表、散列表、二叉搜索树、红黑树、B树、位图）的实现与应用。重点分析了复杂度概念（O(1)到O(n²)）和数据结构选择标准（查询/插入效率、有序性等）。通过括号匹配和BFS等典型示例，展示了栈和队列的实际应用场景。文中推荐优先使用ArrayDeque实现栈/队列，并对比了不同数据结构的适用场景和Java标准库实现（如HashMap、TreeMap等）。全文基于Java 8+，强调理解数据结构
数据结构——双向链表（附图文讲解 | 超详细）
king_linlin的博客
08-14 323
这篇博客将从全面讲解数据结构中的双向链表链表（带头双向循环链表）双向链表主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。它主要结构是由，这三个结构组成，通过prev找到前一个结点，next找下一个结点，data储存链表数据如图所示。
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值