顺序表--C语言版（从0开始，超详细解析 ，小白也能懂）

已于 2023-11-16 20:29:10 修改
阅读量568 收藏 1
点赞数 5
文章标签： 数据结构
于 2023-11-16 20:26:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76675828/article/details/134446284
版权

目录

一，顺序表的概念

🌞什么是顺序表

👍顺序表与数组的区别 

二，顺序表详解

☘️顺序表结构

🖥️静态顺序表

🖥️动态顺序表

三，动态顺序表常见操作的实现

👏顺序表的初始化

👏容量判断

👏顺序表查找

 👏顺序表尾插

 👏顺序表尾删

👏顺序表头插

👏顺序表头删

👏顺序表指定位置插入

👏顺序表指定位置删除

👏打印顺序表

👏销毁顺序表

四，顺序表完整代码

一，顺序表的概念

🌞什么是顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

👍顺序表与数组的区别 

         上面说到顺序表是在计算机内存中以数组的形式保存的线性表，但是与C语言数组是有区别的。例如有一组数据【6 , 7 , 8】分别存入到顺序表和数组当中。

对于顺序表而言，数据的存储是连续的，相邻的。

对于数组而言，不要求在连续的空间上存储数据

二，顺序表详解

☘️顺序表结构

🖥️静态顺序表

知识点：静态顺序表

静态顺序表：使用定长数组存储

优点：操作简单，代码实现容易

缺点：定长数组很受限制，数组开小了不够用，开大了又浪费

🖥️动态顺序表

知识点：动态顺序表

动态顺序表：使用动态开辟的数组进行数据的存储

优点：数组可以根据自己的需求进行调解

缺点：代码过于麻烦

动态顺序表比静态使用范围更广，我们着重来讲述动态的

三，动态顺序表常见操作的实现

//顺序表的动态存储
typedef int SLDatatype;
typedef struct SeqList
{
	SLDataType* Data; //定长数组
	int size;         //有效数据个数
	int capacity;     //空间容量的大小
}SeqList;

👏顺序表的初始化

//初始化链表
void SLInit(SeqList* ps)
{
	assert(ps);   //判空，如果传入的空指针，后面对它进行解引用就会报错
	ps->data = NULL; //将data初始化为空指针
	ps->capacity = ps->size = 0;
}

现在顺序表的初始化完成了，接下来就是顺序表的增删查改了。

在实现顺序表增加元素的函数功能前，首先我们先实现一个检查顺序表是否已经存满。如果已经存满了，那么我们就需要对它进行扩容。

👏容量判断

//容量判断
void Check_Capacity(SeqList* ps)
{
	assert(ps);
	if (ps->capacity == ps->size) //判断顺序表中有效数据个数是否已经达到容量大小
	{
		int new_capacity = ps->capacity == 0 ? 4 : (ps->capacity) * 2;
        //如果容量为0的话，此时就是第一次向顺序表中添加元素，capacity就设为4
        //如果容量不为0，此时就是有效数据个数达到容量，就进行扩容，新容量设置为原容量的2倍
		SLDataType* tmp = (SLDataType*)realloc(ps->data, new_capacity * sizeof(SLDataType));
		if (tmp == NULL)  //如果扩容失败，就终止程序。
		{
			perror("ralloc fail");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = new_capacity;
	}
}

里扩容使用的是realloc函数，当我们进行第一次插入的时候，ps->data指针还是空指针，这时我们也可以使用realloc，realloc函数在使用的时候，如果传入的指针是空指针，它的作用就与malloc相同。 

👏顺序表查找

//顺序表查找
int SL_Find(SeqList* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->data[i] == x)
		{
            //找到就返回下标
			return i;
		}
	}
    //找不到就返回-1
	return -1;
}

 👏顺序表尾插

//顺序表尾插
void SL_PushBack(SL* ps, SLDataType x)
{
	assert(ps);
	Check_Capacity(ps);
	ps->data[ps->size] = x;
	ps->size++;
}

 👏顺序表尾删

//顺序表尾删
void SL_PopBack(SL* ps)
{
	assert(ps);
	assert(ps->size > 0); //如果顺序表中已经没有元素，那么就不用进行删除，所以
                          //这里需要检查顺序表中是否还有元素。
	ps->size--;
}

注意：尾删时要检查顺序表中是否要有元素，下面的头删也是如此

👏顺序表头插

//顺序表头插
void SL_PushFront(SL* ps, SLDataType x)
{
	assert(ps);
	Check_Capacity(ps); //检查容量
    //将所有数据向后移动一位
	for (int i = ps->size - 1; i >= 0; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	ps->data[0] = x;
	ps->size++;
}

头插时将原有的元素向后移动一位，再将新的元素放入头部位置

👏顺序表头删

//顺序表头删
void SL_PopFront(SL* ps)
{
	assert(ps);
    //如果顺序表中只有一个数据，那么直接将数据个数-1
    //如果对数据进行挪动，会造成越界
	if (ps->size == 1)
	{
		ps->size--;
		return;
	}
    //如果数据个数不为1，就将数据中第2个到最后一个都往前移动一位
	for (int i = 1; i < ps->size; i++)
	{
		ps->data[i - 1] = ps->data[i];
	}
	ps->size--;
}

注意：挪动数据时防止数组的越界，顺序表只有一个元素时要考虑到位

👏顺序表指定位置插入

//顺序表指定位置插入
void SL_Insert(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
    //判定pos是否合法
	assert(pos <= ps->size);
	assert(pos >= 0);
	Check_Capacity(ps); //检查容量是否够用
    //将pos位置后的元素全部都向后移动一位
	for (int i = ps->size-1; i >= pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	ps->data[pos] = x;
	ps->size++;
}

注意：插入位置要合法

👏顺序表指定位置删除

//顺序表指定位置删除
void SL_Erase(SeqList* ps, int pos)
{
	assert(ps);
    //检查pos位置是否合法
	assert(pos >= 0);
	assert(pos < ps->size);
    //将pos位置后面的元素全都向前移动一位
	for (int i = pos; i < ps->size; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->size--;
}

👏打印顺序表

//打印顺序表
void SLPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

👏销毁顺序表

//销毁顺序表
void SL_Destroy(SeqList* ps)
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->size = 0;
}

四，顺序表完整代码

SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* data;
	int size;
	int capacity;
}SeqList;
 
//初始化顺序表
void SLInit(SeqList* ps);
 
//删除顺序表
void SL_Destroy(SeqList* ps);
 
//打印顺序表
void SLPrint(SeqList* ps);
 
//检查容量
void Check_Capacity(SeqList* ps);
 
//尾插尾删
void SL_PushBack(SeqList* ps,SLDataType x);
void SL_PopBack(SeqList* ps);
 
//头插头删
void SL_PushFront(SeqList* ps, SLDataType x);
void SL_PopFront(SeqList* ps);
 
//顺序表查找
int SL_Find(SeqList* ps, SLDataType x);
 
//顺序表指定位置插入
void SL_Insert(SeqList* ps, int pos, SLDataType x);
 
//顺序表指定位置删除
void SL_Erase(SeqList* ps, int pos);

SeqList.c

#include "SeqList.h"
 
void SLInit(SeqList* ps)
{
	assert(ps);  
	ps->data = NULL; 
	ps->capacity = ps->size = 0;
}
 
void SL_Destroy(SeqList* ps)
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->size = 0;
}
 
void SLPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}
 
void Check_Capacity(SeqList* ps)
{
	assert(ps);
	if (ps->capacity == ps->size) 
	{
		int new_capacity = ps->capacity == 0 ? 4 : (ps->capacity) * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->data, new_capacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("ralloc fail");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = new_capacity;
	}
}
 
void SL_PushBack(SeqList* ps, SLDataType x)
{
	//assert(ps);
	//Check_Capacity(ps);
	//ps->a[ps->size] = x;
	//ps->size++;
	SL_Insert(ps, ps->size, x);
}
 
void SL_PopBack(SeqList* ps)
{
	//assert(ps);
	//assert(ps->size > 0);
	//ps->size--;
	SL_Erase(ps, ps->size - 1);
}
 
void SL_PushFront(SeqList* ps, SLDataType x)
{
	//assert(ps);
	//Check_Capacity(ps);
	//for (int i = ps->size - 1; i >= 0; i--)
	//{
	//	ps->a[i + 1] = ps->a[i];
	//}
	//ps->a[0] = x;
	//ps->size++;
	SL_Insert(ps, 0, x);
}
 
void SL_PopFront(SeqList* ps)
{
	//assert(ps);
	//if (ps->size == 1)
	//{
	//	ps->size--;
	//	return;
	//}
	//for (int i = 1; i < ps->size; i++)
	//{
	//	ps->data[i - 1] = ps->data[i];
	//}
	//ps->size--;
	SL_Erase(ps,0);
}
 
int SL_Find(SeqList* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->data[i] == x)
		{
			return i;
		}
	}
	return -1;
}
 
void SL_Insert(SeqList* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos <= ps->size);
	assert(pos >= 0);
	Check_Capacity(ps);
	for (int i = ps->size-1; i >= pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	ps->data[pos] = x;
	ps->size++;
}
 
void SL_Erase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	for (int i = pos; i < ps->size; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->size--;
}

以上就是顺序表基本操作的内容了，希望可以帮助到大家，如有不足的地方，评论区欢迎留言讨论

BIGPIG甘十六
关注
从零开始学习C语言
qq_43708708的博客
04-09 2879
该文章提供了C语言学习的基础知识和技巧，包括数据类型、变量、控制流、数组、函数等内容。通过清晰的解释和示例，帮助初学者建立起对C语言编程的理解和技能。
【C语言】扫雷—初学者也能写的小游戏
热门推荐
iluo12的博客
01-15 1万+
适合C语言【初学者】的小游戏 217行代码写出扫雷
顺序表详解
NoobNo2的博客
04-15 998
顺序表是咱学习数据结构时接触到的第一种数据结构。在学习顺序表之前，我们需要先弄明白一个问题：何为数据结构？数据结构，单从字面上来讲就是数据的结构。设想一下，内存中有一大堆数据（假设这些数据是数字1、2、3...等等）然后我们想在这堆数据中找到并拿出其中一个数据 “3” ，要怎么找呢？这时候就需要用到数据结构的知识——将数据有序的存储起来（排序），接着就只需要访问对应的序列就能找到该数据了。1.能够储存数据2.储存的数据方便查找（删除、或者修改）
(C语言数据结构) 顺序表
09-16
C语言实现 顺序表 Init(初始化) Length(当前结点个数) Add(添加) Insert(插入) Delete(删除) FindByKey(查找返回序号) FindByNum(查找返回元素) ShowAll(显示所有元素)
数据结构: 顺序表(Seqlist篇) 手把手带你了解数据结构~
最新发布
Jdxxwu的博客
09-20 1275
手把手带你入门数据结构顺序表，图文详解，总结有源码奉上，观众老爷们有需要的话自取哦~
C语言顺序表
qq_29468639的博客
10-31 1844
C语言顺序表概念及结构静态顺序表动态顺序表接口实现(动态)顺序表的优缺点优点缺点 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。 在数组上完成数据的增删查改。 顺序表一般可以分为: 静态顺序表:使用定长数组存储元素。 动态顺序表:使用动态开辟的数组存储。 静态顺序表 代码实现 #define N 10 //这表示顺序表最多存储的数据 typedef int Datatype; typedef struct SeqList { D
C语言——顺序表
学习C++的小陈同学
11-23 549
C语言实现顺序表
顺序表（C语言详细版）
李白同学的博客
07-01 957
线性表(lina list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串......线性表在逻辑上是线性结构，也就是说连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
大数据最新【中秋特辑-代码解析月饼节】C++比C语言更加规范、方便
2401_84181286的博客
05-04 888
⭐正是有函数名修饰规则的加持下，让C++相较于C语言上有了更加丰富的实现⭐如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回如果已经还给系统了，则必须使用传值返回⭐C++可以利用内联函数替代宏函数。
C语言：删除有序链表大于mink小于maxk的数
weixin_55797565的博客
10-30 2082
将链表变成有序链表并定义mink和maxk，删除大于mink和小于maxk的数据，mink和maxk可不与链表数据相同。 //代码 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 10 #define OK 1 #define ERROR 0 #define T 1 #define F -1 typedef int Status; typedef struct Dli
Free RTOS入门解析---tasks.c文件源码分解
weixin_45452434的博客
02-16 439
Free RTOS入门解析---tasks.c文件源码分解，自己学习中的一些理解
【数据结构】顺序表（C语言）
weixin_44358957的博客
03-06 1760
数据结构，顺序表（C语言，带注释）
顺序表——C语言
jin_jue_qi的博客
09-30 1587
顺序表的结构就是数组结构，基本操作比较简单。                                                                                  结构如图        顺序表的增加，删除，查询，也是对不同下标的元素进行操作。 顺序表的增加：若顺序表在i位置增加，则将i以后的所以数组元素向后移动，将原来i位置的数值用增加数值代替。...
顺序表（C语言实现）
trqii_的博客
04-26 5801
顺序表 文章目录顺序表一、**顺序表的基本概念**二、动态顺序表的具体实现1. 顺序表初始化2. 顺序表尾插3. 顺序表头插4. 顺序表尾删5. 顺序表头删6. 顺序表任意位置插入7. 顺序表任意位置删除8. 顺序表查找9. 顺序表修改10. 顺序表打印11. 顺序表销毁三、完整代码 一、顺序表的基本概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表分为以下二类： 1.静态顺序表：使用定长数组存储元素。 #define N
C语言-数据结构之顺序表
2301_81486828的博客
01-29 728
线性表（）是n个具有相同特性的数据元素的有限序列, 线性表是⼀种在实际中⼴泛使⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。简单来说顺序表是线性表的一种,而且逻辑和物理都是线性结构2.顺序表的定义和分类顺序表的底层是数组,通过增加一些增删查找等接口实现2.1 静态顺序表静态顺序表(这里拿里面存储的整形举例)int size;
[C语言数据结构]顺序表
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
10-30 392
使用c语言实现动态顺序表的万字详解！
C语言实现顺序表与单链表逆置操作
本资源是一份关于C语言实现顺序表和单链表逆置操作的教学文档。主要关注的是顺序表和单链表这两种基础数据结构在C语言中的实现以及它们的逆置操作。以下是详细的知识点解析： 1. **顺序表（数组实现）**: - 使用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值