数据结构——顺序表

最新推荐文章于 2025-06-12 20:18:06 发布
原创 最新推荐文章于 2025-06-12 20:18:06 发布
· 1.3k 阅读 · 24 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

本文详细介绍了顺序表的概念、特点，包括静态顺序表与动态顺序表的比较，以及如何通过动态内存实现顺序表的初始化、销毁、打印、扩容、头部/尾部插入/删除和查找操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

前言

一、线性表

二、顺序表

三、动态顺序表的实现

3.1 顺序表初始化和销毁

3.2 打印顺序表

3.3 扩容顺序表

3.4 顺序表头部插入和尾部插入

3.5 顺序表头部删除和尾部删除

3.6 插入任意位置

3.7 删除任意位置

3.8 查找任意元素

四、实现代码

总结

前言

今天我们来讲数据结构方面的知识，数据结构是由“数据”和“结构”两词组合而来。

数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在⼀种或多种特定关系的数据元素的集合。数据结构反映数据的内部构成，即数据由那部分构成，以什么方式构成，以及数据元素之间呈现的结构。

通过数据结构，能够有效将数据组织和管理在⼀起。按照我们的方式任意对数据进行增删改查等操作。最基础的数据结构：数组

但是最基础的数据结构能够提供的操作已经不能完全满足复杂算法实现。所以我们今天来讲数据结构中的线性表。

一、线性表

线性表（linear list）是n个具有相同特性的数据元素的 有限序列 。 线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以 数组和链式结构 的形式存储。
其中顺序表是一种线性表，逻辑上是线性的，物理结构上为连续的。

二、顺序表

采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 通常形式为数组。
顺序表分类
◦ 静态顺序表
概念：使用 定长数组 存储元素
​
但是静态顺序表有缺陷， 空间给少了不够用，给多了造成空间浪费
◦ 动态顺序表
概念：使用 动态内存开辟数组 存储元素

​

• 顺序表和数组的区别
  顺序表的底层结构是 数组 ，对数组的 封装 ，实现了常⽤的增删改查等接口

三、动态顺序表的实现

代码接口：

typedef int SLDataType;

typedef struct Seqlist {
	SLDataType* arr;
	int size;		//有效数据个数
	int	capacity;  //数组容量
} SL;

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

//扩容
void SLCheckCapacity(SL* ps);
//头部插入
void SLPushFront(SL* ps, SLDataType x);
//尾部插入
void SLPushBack(SL* ps, SLDataType x);
//头部删除
void SLPopFront(SL* ps);
//尾部删除
void SLPopBack(SL* ps);
//插入任意位置
void SLInsert(SL* ps, int pos, SLDataType x);
//删除任意位置
void SLErase(SL* ps, int pos);
//查找元素
int SLFind(SL* ps, SLDataType x);

3.1 顺序表初始化和销毁

顺序表的初始化

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

我们先把开辟的数组指针先为空指针，把数组的有效元素大小和数组大小置为空。

顺序表的销毁

void SLDestroy(SL* ps) {
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
}

我们先用assert判断一下顺序表是否为空，释放开辟的空间，把开辟空间的起始地址置为空。

3.2 打印顺序表

如果我们想知道顺序表的内容，我们就可以打印顺序表的内容

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

跟打印数组一样，打印个数小于有效的数据的个数(因为下标从0开始)

3.3 扩容顺序表

如果我们要对数组进行插入操作，我们就要判断顺序表空间是否已满，如果已满我们就要对顺序表进行扩容操作。

但是扩容规则有：

依次扩容一个空间                  缺点：程序效率低下

依次扩容固定的空间               缺点：小了会频繁扩容，大了会空间浪费

成倍数的增加扩容空间 (一般为1.5或者2倍） 

我们使用成倍数的增加扩容空间(如4，8，16，32)，这样可以减少扩容次数，大了不会浪费过多空间。

void SLCheckCapacity(SL* ps) {
	if (ps->size == ps->capacity) //判断是否已满{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
                               //如果初始化为零，则赋值大小为4，反之扩容为以前大小的2倍
		SLDataType* t = ps->arr;
		t= (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));//扩容
		if (t == NULL) {
			perror(" SLCheckCapacity error");
			exit(1);
		}
		ps->arr = t;//地址为扩容后新的地址
		ps->capacity = newcapacity;//大小为扩容后的大小
		
	}
}

3.4 顺序表头部插入和尾部插入

头部插入

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++;//有效数据个数加1

}

从后往前移动：

尾部插入

void SLPushBack(SL* ps, SLDataType x) {
	assert(ps);
	SLCheckCapacity(ps);//扩容

	ps->arr[ps->size++] = x;
}

直接在数组的末尾加入x，然后有效数据个数加1。

3.5 顺序表头部删除和尾部删除

头部删除

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--;//有效数据个数减1
}

从前往后移动

尾部删除

void SLPopBack(SL* ps){
	assert(ps);
	assert(ps->size);
	ps->size--;
}

3.6 插入任意位置

void SLInsert(SL* ps, int pos, SLDataType x) {
	assert(ps);
	SLCheckCapacity(ps);
	for (int i = ps->size; i > pos; i--) {
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

插入位置后的元素往后移一位，我们从后往前移动，从size位置开始，到pos加1的位置。

3.7 删除任意位置

void SLErase(SL* ps, int pos) {
	assert(ps && ps->size);
	for (int i = pos; i < ps->size-1;i++) {
		ps->arr[i] = ps->arr[i+1];
	}
	ps->size--;
}

删除位置后的元素往前移一位，我们从前往后移动，从pos位置开始，到size减2的位置。

3.8 查找任意元素

int SLFind(SL* ps, SLDataType x) {
	assert(ps && ps->size);//判空
	for (int i = 0; i < ps->size; i++) {
		if (ps->arr[i] == x)
			return i+1;//找到了返回位置(从1开始)
	}
	return 0;//没找到返回零
}

四、实现代码

接口的定义

seqlist.h

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

typedef int SLDataType;

typedef struct Seqlist {
	SLDataType* arr;
	int size;		//有效数据个数
	int	capacity;  //数组容量
} SL;

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

//扩容
void SLCheckCapacity(SL* ps);
//头部插入
void SLPushFront(SL* ps, SLDataType x);
//尾部插入
void SLPushBack(SL* ps, SLDataType x);
//头部删除
void SLPopFront(SL* ps);
//尾部删除
void SLPopBack(SL* ps);
//插入任意位置
void SLInsert(SL* ps, int pos, SLDataType x);
//删除任意位置
void SLErase(SL* ps, int pos);
//查找元素
int SLFind(SL* ps, SLDataType x);

接口的具体实现

seqlist.h

#define _CRT_SECURE_NO_WARNINGS 1
#include "Seqlist.h"

//初始化
void SLInit(SL* ps){
	ps->arr =NULL;
	ps->size = ps->capacity = 0;
}
//销毁
void SLDestroy(SL* ps) {
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
}
//打印
void SLPrint(SL* ps) {
	assert(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;
		SLDataType* t = ps->arr;
		t= (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		if (t == NULL) {
			perror(" SLCheckCapacity error");
			exit(1);
		}
		ps->arr = t;
		ps->capacity = newcapacity;
		
	}
}

//头部插入
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++;

}
//尾部插入
void SLPushBack(SL* ps, SLDataType x) {
	assert(ps);
	SLCheckCapacity(ps);

	ps->arr[ps->size++] = x;
}
//头部删除
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 SLPopBack(SL* ps){
	assert(ps);
	assert(ps->size);
	ps->size--;
}

//插入任意位置
void SLInsert(SL* ps, int pos, SLDataType x) {
	assert(ps);
	SLCheckCapacity(ps);
	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);
	for (int i = pos; i < ps->size-1;i++) {
		ps->arr[i] = ps->arr[i+1];
	}
	ps->size--;
}
//查找元素
int SLFind(SL* ps, SLDataType x) {
	assert(ps && ps->size);
	for (int i = 0; i < ps->size; i++) {
		if (ps->arr[i] == x)
			return i+1;
	}
	return 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"

void Seqlist_test() {
	//初始化
	SL s;
	SLInit(&s);
	
	//尾部插入
	SLPushBack(&s,1);
	SLPushBack(&s,2);
	SLPushBack(&s,3);
	SLPushBack(&s,4);
	SLPrint(&s);  //1 2 3 4
	//头部插入
	//SLPushFront(&s,0);
	//SLPrint(&s);

	//头部删除
	 //SLPopFront(&s);
	 //SLPrint(&s);
	//尾部删除
	 //SLPopBack(&s);
	 //SLPrint(&s);

	//任意位置插入
	SLInsert(&s,1 ,8 );
	SLPrint(&s);
	//SLPrint(&s);
	//任意位置删除
	//SLErase(&s, 2);
	//SLPrint(&s);
	int ret = SLFind(&s, 8);
	if (ret)
		printf("找到了是第%d个元素", ret);
	else
		printf("没找到");
}


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

总结

上述文章，我们讲了数据结构中的线性表的一种顺序表，讲了顺序表的定义和具体实现，希望对你有所帮助。

回首o
关注
python数据结构——顺序表
fyire的博客
08-15 780
1. 顺序表的定义 数据元素连续存储，并且每个元素的存储空间大小相同，元素下标是逻辑地址，元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定。 2. 顺序表的优点 由于元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定，因此要访问一个元素不用做遍历操作，只需给定逻辑地址就可是实现访问。 计算物理地址的公式如下： 其中表示逻辑地址，表示第 给元素，表示存储区的起始地址， 表示每个元素存...
一招帮你搞懂数据结构的插入、删除
m0_74977981的博客
11-05 1059
在三、的基础上：删除一项时，可以直接从前向后遍历数组去寻找这一项数据，但是这种方法只适合删除一项的情况，因为从后向前覆盖和从前向后查找很容易产生盲区，导致删除不干净的现象，为此统一-->查找时也从后向前查找。而且String类型是不可变的，所以一旦满数组后，需要进行扩容，为了解决String类型不可变的问题，可以采用其他类型，详细可见。完成上述过程后，就可以进行后移动操作（将插入位置后的数据全部后移一个位置，为插入数据留位置），防止数据产生覆盖而丢失的现象。首先，时刻了解Java运行的内存图，参见。
数据结构：顺序表的插入和删除
w912q的博客
01-04 4087
总代码在最后哦！一、了解顺序表顺序表是线性表的顺序存储，它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。需要注意的是顺序表中第一个元素的下标是从开始的。
顺序表插入和删除(数据结构与算法)
AII_IIA的博客
10-26 9577
顺序表是一种数据结构，其元素在内存中连续存储，并且可以使用下标直接访问每个元素。在顺序表中插入或删除元素时，需要移动后续元素的位置以保持顺序表的有序性。 对于在下标位置i处插入值为x的元素，需要将下标为i~n-1的所有元素向右移动一个位置，然后将x插入到位置i的元素中。 对于删除操作，需要将下标为i+1~n-1的所有元素向左移动一个位置，然后将下标为n-1的元素置空。 需要注意的是，当动态扩展顺序表时，需要重新分配内存空间，因为当前内存空间可能已经被占满了。同时，为了减少多次扩充内存空间的开销，可以考虑一次
数据结构——顺序表的合并
热门推荐
qq_45966201的博客
02-02 1万+
数据结构——顺序表的合并 具体要求：写一个函数，其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体，只有先定义了顺序表的结构体类型，才可以继续进行下一步操作 #define maxsize 100 typedef struct { int elem[maxsize];//线性表元素 int last;//线性表长度 }SeqList; 二、顺序表的操作 1.生成顺序表 在有了顺序表的结构之后，
初识数据结构——顺序表
2403_88122966的博客
02-27 1156
简单介绍数据结构的概念，讲解数据结构的其中一种——顺序表
数据结构——顺序表详解
weixin_51785373的博客
10-05 7803
定义顺序表是一种线性表的存储结构，它用一组地址连续的存储单位依次存储线性表中的数据元素。从而使得逻辑上相邻的两个元素在物理位置上也相邻。顺序表具有动态分配空间、支持随机访问和顺序访问,逻辑顺序与物理顺序一致。每个元素可以都有唯一的位置，可以通过索引直接访问元素。元素可以是任意类型，包括基本数据类型、结构体等。
数据结构——顺序表（定义、实现）
weixin_62677583的博客
12-19 3348
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
C++数据结构——顺序表——数值统计
qq_48335434的博客
04-05 465
顺序表
数据结构——顺序表（C语言编写）
新手小白
09-17 8650
数据结构，顺序表应用 插入、删除、合并...
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构 - 栈与队列
Xingshi89的专栏
06-09 217
栈又称为后进先出的线性表（Last In First Out , LIFO）。是一种先进先出的线性表（First In Fist Out , FIFO）。它只允许在表的一端进行插入，而在另一端删除元素。：限定仅在表尾进行插入或删除操作的。在队列中，允许插入的一端称为。表尾端有特殊含义，称为。，允许删除的一端则称为。
从零手写Java版本的LSM Tree （二）：KeyValue 数据结构
翊歌
06-09 911
KeyValue 数据结构 的核心深度剖析
ZeenWoman 公司数据结构文档
a222232s的博客
06-09 867
以下是为给定 JSON 数据生成的.md。
数据结构 (树) 学习 2025年6月12日12:59:39
梦境虽美,却不长.
06-12 588
左旋和右旋是平衡的核心，需熟练掌握四种不平衡情况的处理。
数据结构-文件
06-09 293
多重表文件，对每个次关键字也建立一个索引，并且将具有相同次关键字的记录的物理地址链接起来，次关键字索引表的一条记录包括次关键字、链表的头指针、链表长度。ISAM文件由多级主索引、柱面索引、磁道索引、主文件组成。索引表指明逻辑记录和物理记录的对应关系，索引表和主文件一起构成索引文件，在存储器上分为索引区和数据区。主文件分为索引顺序文件和索引非顺序文件，索引非顺序文件适合随机存取，索引顺序文件适合于顺序存取。倒排文件，与多重表文件相比，倒排文件把链表的物理地址放在了次关键字索引表中了。
算法导论第三章：数据结构艺术与高效实现
最新发布
SEU123WW的博客
06-12 657
本文是《算法导论》精讲专栏第三章，通过动态操作可视化、内存布局图解和性能对比实验，结合完整C语言实现，深入解析数据结构核心原理。包含栈、队列、链表、散列表、二叉树等完整实现，以及工程实践中的优化技巧。
湖南大学数据结构实验1——顺序表项目源码解析
资源摘要信息:"湖南大学数据结构实验1顺序表.zip" 从标题、描述、标签和压缩包内的文件列表来看，这个压缩包包含的是关于数据结构课程的实验材料，特别关注于顺序表的实现和操作。顺序表是一种线性表的存储结构，其...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值