【数据结构】顺序表

小羊在奋斗2024-06-18 16:44

Hi~！这里是奋斗的小羊，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
💥💥个人主页：奋斗的小羊
💥💥所属专栏：C语言

🚀本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。

目录

  • 前言
  • 1、数据结构
  • 2、线性表
  • 3、顺序表
    • [3.1 为什么要有顺序表？](#3.1 为什么要有顺序表？)
    • [3.2 创建和初始化](#3.2 创建和初始化)
    • [3.3 头插](#3.3 头插)
    • [3.4 尾插](#3.4 尾插)
    • [3.5 在指定位置前插入](#3.5 在指定位置前插入)
    • [3.6 头删](#3.6 头删)
    • [3.7 尾删](#3.7 尾删)
    • [3.8 删除指定位置的数据](#3.8 删除指定位置的数据)
    • [3.9 顺序表的查找](#3.9 顺序表的查找)
    • [3.10 顺序表销毁](#3.10 顺序表销毁)
    • [3.11 测试](#3.11 测试)
  • 总结

前言

本篇文章将详细介绍顺序表的基本搭建过程。

我们都知道顺序表的底层其实就是数组，但是既然有了数组为什么还要有顺序表呢？

其实相比如数组，顺序表还是有很多优势的。比如动态扩容、增删查改效率高、支持动态元素类型、停供更多的操作方法等。顺序表相对于数组具有更高的灵活性和功能性，可以更方便地对数据进行操作和管理。

1、数据结构

数据结构是由"数据"和"结构"两词组成。

什么是数据？数据是记录事实、观察结果或描述信息的集合，通常以数字、文字、图像或声音的形式存在。

什么是结构？简单来说结构就是组织数据的方式。

数据结构是指计算机存储、组织和管理数据的方式。

2、线性表

线性表是n个具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，常见的线性表有：顺序表、链表、栈、队列、字符串......

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

3、顺序表

3.1 为什么要有顺序表？

顺序表的底层其实就是数组。

顺序表是线性表的一种，并且顺序表在逻辑上和物理上都是线性的。

数组就可以管理数据，为什么还要有顺序表呢？数组也可以实现一些增删查改的操作，但是实现起来比较麻烦，于是顺序表就把这些比较麻烦的操作封装好，使我们使用起来更加方便。

顺序表也分静态顺序表 和动态顺序表 。
静态顺序表 底层是定长数组，空间给大了浪费，给小了不够，有缺陷。
动态顺序表 的空间大小是可变的，是由动态内存函数realloc对开辟的动态内存空间进行调整。

我们通常使用动态顺序表。

3.2 创建和初始化

首先我们需要一个指针来接收由动态内存函数开辟的空间，还需要一个变量记录当前顺序表内数据个数，因为我们创建的是动态顺序表，大小经常变化，所以我们还需要一个变量来记录当前空间的大小。最后我们再把这些值封装到一个结构体中，这个结构体就是我们要创建的动态顺序表。

c 复制代码 
//顺序表管理数据的类型
typedef int sl_data_type;

typedef struct seqlist
{
	sl_data_type* arr;
	int size;//数据个数
	int capacity;//空间大小
}SL;

我们希望创建的顺序表能管理多种类型的数据，所以使用类型重定义标识符typedef。

创建好顺序表后，为了以后使用方便我们将它的初始化步骤也分装成一个函数：

c 复制代码 
void sl_init(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

注意指针要赋NULL。

3.3 头插

创建和初始化顺序表后，我们来实现在顺序表头部插入数据。

插入数据是直接插吗？不是的，我们还需要判断当前顺序表中是否有足够的空间让我们插入数据，因为不管是哪种插入的方式都要进行判断，所以我们干脆把这一步骤分装成一个函数，方便后续使用。

如何判断当前顺序表是否有足够的空间呢？是ps->capacity>0吗？

不是的，因为有一种特殊情况是当前顺序表的空间刚好被使用完，合理的判断条件是当ps->size == ps->capacity时，我们申请空间。

但是申请空间又有一个问题摆在我们面前：申请多大？仿佛又回到了定长数组的问题。

不过不要慌，由数学推理得出，一次申请空间大小是原空间大小2倍最合理。

c 复制代码 
//检查是否有空间允许插入数据
void check_capacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//为了处理capacity为0的问题
		sl_data_type* tmp = (sl_data_type*)realloc(ps->arr, newcapacity * sizeof(sl_data_type));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		tmp = NULL;
		ps->capacity = newcapacity;//及时更新空间大小
	}
}

空间大小需要乘以相应类型的大小。

在使用realloc函数时不要忘了其返回值也有为NULL的可能，所以需要一个临时指针过渡，这个临时指针使用完也不要忘了赋NULL，以防止其成为野指针。

顺序表的空间大小最后也不要忘了及时更新。

判断是否有足够的空间后，接下来就是在顺序表的头部插入数据。

我们先要将原先的数据向后挪动一位，将顺序表的第一位空出来，插入我们想插入的数据。

c 复制代码 
void sl_push_front(SL* ps, sl_data_type x)
{
	assert(ps != NULL);
	check_capacity(ps);
	int i = 0;
	for (i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

开始插入操作之前，为了防止意外我们先判断一下传过来的顺序表的指针是否为空。

最后不要忘了给顺序表内记录数据个数的变量++。

3.4 尾插

相比于头插，尾插没有挪动原有数据的操作，在判断完空间大小和数据个数后直接在数据末尾插入就行，同样也不要忘了让记录数据个数的变量++

c 复制代码 
void sl_push_back(SL* ps, sl_data_type x)
{
	assert(ps != NULL);
	check_capacity(ps);
	ps->arr[ps->size++] = x;
}

3.5 在指定位置前插入

顺序表中不止在头部和尾部插入数据，也可在指定的任意有效位置插入数据，所以我们的函数就要多一个指定位置的参数。

指定的位置还必须要有效，因为顺序表中的数据一定是连续的。

插入之前，我们需要将指定位置后面的数据往后挪动一位，给要插入的数据留出空间。

c 复制代码 
void sl_insert(SL* ps, int pos, sl_data_type x)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos <= ps->size);//确保指定的位置是有效的
	check_capacity(ps);
	int i = 0;
	for (i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

插入数据后，记录数据个数的变量不要忘了++。

3.6 头删

在删除完顺序表的第一个数据后，也需要将剩余的数据向前挪动一位，以确保数据是在下标为0处开始。

在删除数据之前，我们还要考虑到一种特殊情况，就是当前顺序表中没有数据，那没有数据肯定是不能进行删除操作的。

c 复制代码 
void sl_pop_front(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size != 0);//顺序表为空不能删除
	int i = 0;
	for (i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

删除操作完成后，数据个数--；

3.7 尾删

尾删则比较简单，因为我们只需要让记录数据个数的变量-1，在访问顺序表的时候访问不到这个数据，就相当于删除了这个数据

同样的，尾删也需要考虑当前数据个数是否为0的情况。

c 复制代码 
void sl_pop_back(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size != 0);//顺序表为空不能删除
	ps->size--;
}

3.8 删除指定位置的数据

这个指定的位置也必须是有效的。

同时也要保证当前顺序表中的数据个数不为0。

c 复制代码 
void sl_erase(SL* ps, int pos)
{
	assert(ps != NULL);
	assert(ps->size != 0);//实际下面的断言侧面完成了这句代码
	assert(pos >= 0 && pos < ps->size);//确保指定的位置是有效的
	int i = 0;
	for (i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

3.9 顺序表的查找

想要在顺序表中查找一个数据，只需要像遍历数组一样遍历顺序表就行。

找到则返回数据对应的下标，找不到则返回-1。

c 复制代码 
int sl_find(SL* ps, sl_data_type x)
{
	assert(ps != NULL);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

3.10 顺序表销毁

我们向内存申请了一块空间使用完成后，还要归还给操作系统

在上面调整顺序表大小的操作中，我们使用的是动态内存函数realloc，因此还要使用函数free释放掉动态开辟的空间，也不要忘了给指针赋NULL

c 复制代码 
void sl_destroy(SL* ps)
{
	assert(ps != NULL);
	if (ps->arr != NULL)//动态内存函数开辟了空间
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

3.11 测试

为了对我们创建的顺序表进行测试，方便起见再写一个打印函数。

c 复制代码 
void sl_print(const SL sl)
{
	int i = 0;
	for (i = 0; i < sl.size; i++)
	{
		printf("%d ", sl.arr[i]);
	}
	printf("\n");
}

测试代码如下：

c 复制代码 
void test()
{
	SL sl;
	sl_init(&sl);
	sl_push_front(&sl, 1);
	sl_push_front(&sl, 2);
	sl_push_front(&sl, 3);
	sl_print(sl);

	sl_push_back(&sl, 4);
	sl_push_back(&sl, 5);
	sl_push_back(&sl, 6);
	sl_print(sl);

	sl_pop_front(&sl);
	sl_print(sl);

	sl_pop_back(&sl);
	sl_print(sl);

	sl_pop_front(&sl);
	sl_print(sl);

	sl_pop_back(&sl);
	sl_print(sl);

	sl_pop_front(&sl);
	sl_print(sl);

	sl_pop_back(&sl);
	sl_print(sl);

	sl_destroy(&sl);
}

运行结果：

结果和我们预期的效果一致。

整个程序的原码如下：
seqlist.h:

c 复制代码 
#pragma once

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

//顺序表管理数据的类型
typedef int sl_data_type;

typedef struct seqlist
{
	sl_data_type* arr;
	int size;//数据个数
	int capacity;//空间大小
}SL;

//顺序表初始化
void sl_init(SL* ps);
//头插
void sl_push_front(SL* ps, sl_data_type x);
//尾插
void sl_push_back(SL* ps, sl_data_type x);
//在指定位置之前插入数据
void sl_insert(SL* ps, int pos, sl_data_type x);
//头删
void sl_pop_front(SL* ps);
//尾删
void sl_pop_back(SL* ps);
//删除指定位置的数据
void sl_erase(SL* ps, int pos);
//顺序表的查找
int sl_find(SL* ps, sl_data_type x);
//顺序表打印
void sl_print(const SL sl);
//顺序表销毁
void sl_destroy(SL* ps);

seqlist.c:

c 复制代码 
#define  _CRT_SECURE_NO_WARNINGS

#include "seqlist.h"

void sl_init(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

//检查是否有空间允许插入数据
void check_capacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//为了处理capacity为0的问题
		sl_data_type* tmp = (sl_data_type*)realloc(ps->arr, newcapacity * sizeof(sl_data_type));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		tmp = NULL;
		ps->capacity = newcapacity;//及时更新空间大小
	}
}

void sl_push_front(SL* ps, sl_data_type x)
{
	assert(ps != NULL);
	check_capacity(ps);
	int i = 0;
	for (i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

void sl_push_back(SL* ps, sl_data_type x)
{
	assert(ps != NULL);
	check_capacity(ps);
	ps->arr[ps->size++] = x;
}

void sl_insert(SL* ps, int pos, sl_data_type x)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos <= ps->size);//确保指定的位置是有效的
	check_capacity(ps);
	int i = 0;
	for (i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

void sl_pop_front(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size != 0);//顺序表为空不能删除
	int i = 0;
	for (i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

void sl_pop_back(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size != 0);//顺序表为空不能删除
	ps->size--;
}

void sl_erase(SL* ps, int pos)
{
	assert(ps != NULL);
	assert(ps->size != 0);
	assert(pos >= 0 && pos < ps->size);//确保指定的位置是有效的
	int i = 0;
	for (i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

int sl_find(SL* ps, sl_data_type x)
{
	assert(ps != NULL);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

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

void sl_destroy(SL* ps)
{
	assert(ps != NULL);
	if (ps->arr != NULL)//动态内存函数开辟了空间
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

test.c:

c 复制代码 
#define  _CRT_SECURE_NO_WARNINGS

#include "seqlist.h"

void test()
{
	SL sl;
	sl_init(&sl);
	sl_push_front(&sl, 1);
	sl_push_front(&sl, 2);
	sl_push_front(&sl, 3);
	sl_print(sl);

	sl_push_back(&sl, 4);
	sl_push_back(&sl, 5);
	sl_push_back(&sl, 6);
	sl_print(sl);

	sl_pop_front(&sl);
	sl_print(sl);

	sl_pop_back(&sl);
	sl_print(sl);

	sl_pop_front(&sl);
	sl_print(sl);

	sl_pop_back(&sl);
	sl_print(sl);

	sl_pop_front(&sl);
	sl_print(sl);

	sl_pop_back(&sl);
	sl_print(sl);

	sl_insert(&sl, 0, 4);
	sl_print(sl);

	sl_erase(&sl, 1);
	sl_print(sl);
	
	int ret = sl_find(&sl, 3);
	if (ret >= 0)
	{
		printf("%d\n", sl.arr[ret]);
	}
	else
	{
		printf("没找到");
	}
	
	sl_destroy(&sl);
}

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

总结

  • 我们常用的是动态顺序表，通过realloc函数来对空间大小适当的扩容
  • 顺序表中的元素在内存中是连续存储的，可以通过下标直接访问元素，提高了查找效率
  • 适合： 频繁访问、很少插入和删除的数据集合。由于顺序表支持通过下标直接访问元素，适合频繁读取和遍历元素的场景
  • 不适合： 频繁插入和删除的场景。由于插入和删除操作需要移动数据，频繁插入和删除会影响性能，不适合该类场景
相关推荐
阿里巴巴P8资深技术专家3 小时前
Java常用算法&集合扩容机制分析
java·数据结构·算法
逸群不凡7 小时前
C++|哈希应用-＞布隆过滤器
开发语言·数据结构·c++·算法·哈希算法
HHFQ8 小时前
狄克斯特拉算法
数据结构·算法
0xCC说逆向11 小时前
数据结构 - C/C++ - 队列
数据结构
码界领航11 小时前
(6) 深入理解pandas的核心数据结构：DataFrame全面解析
数据结构·python·numpy·pandas
danaaaa12 小时前
力扣刷题练习八【922. 按奇偶排序数组II】
数据结构·c++·算法·leetcode·职场和发展
青釉Oo12 小时前
数字流的秩
java·数据结构·算法·leetcode·二叉搜索树
小字节，大梦想13 小时前
C语言_练习题
c语言·开发语言·数据结构·后端·算法·leetcode
wcy20009713 小时前
代码随想录训练营Day56
数据结构·算法·leetcode
wenpingyang13 小时前
算法刷题1-10大排序算法汇总
数据结构·算法
热门推荐
01Coze扣子平台完整体验和实践（附国内和国际版对比）02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03【经验分享】Ubuntu22.04安装微信(linux官方版)042024亚太赛（中文赛）数学建模竞赛选题建议+初步分析05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解07YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU082025张宇考研数学，百度网盘视频课+36讲PDF讲义+真题09通达信神奇九转指标原理及选股公式，无未来函数，数字不消失10【极空间NAS】使用WebDAV服务 + DDNSTO内网穿透 实现思源笔记的内外网同步