数据结构_线性表_顺序表（C语言实现+超详细逐步解析

已于 2024-03-20 22:52:58 修改
阅读量1.3k 收藏 11
点赞数 32
分类专栏： 数据结构 文章标签： 数据结构 c语言 开发语言
于 2024-01-26 14:03:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73726899/article/details/135863110
版权

系列文章

​
单链表基本操作（详解
数据结构_线性表_顺序表（C语言实现+超详细逐步解析
双向链表（详解
栈的基本操作
​

顺序表

具体的代码文件可在gitee获取！！！
https://gitee.com/yan-haixuan/learning_Byte_c/tree/master/SeqList

1、顺序表基本概念

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

具备以下特点：连续存储、随机访问、插入和删除的复杂度较高、固定长度

实际我们可以通过画图更加清晰的了解顺序表！！！

在这里插入图片描述

2、顺序表的定义与初始化

（1）静态顺序表: 定长数组存储元素。

数组长度固定，当数据较少时，浪费空间。
反之，数据量较多时，空间不够用！

//静态顺序表
typedef int SLDataType;//定义数据类型
#define N 100   //宏定义  数组长度
struct SeqList {
	int a[N];//数组
	int size;//有效数据个数
};

（2）动态顺序表: 动态开辟数组存储 。

//动态顺序表
typedef int SLDataType;//定义数据类型
//使用结构体SeqList 
typedef struct SeqList {
	SLDataType* a;//指向数组的指针
	int size;	//存储数据个数
	int capacity;//开辟空间的总容量
}SL;

定义了一个结构体SeqList ,命名为SL。

3、SeqList.h接口的实现

内容：

各种头文件
顺序表定义
顺序表的各个函数的声明

1） 头文件
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
2）定义
typedef int SLDataType;

typedef struct SeqList {
	SLDataType* a;//指向数组的指针
	int size;	//存储数据个数
	int capacity;//开辟空间的总容量
}SL;
3）函数声明
//函数声明
void SLInit(SL* s);//初始化

void SLDestroy(SL* s);//销毁

void SLPrint(SL* s);//打印

//检查容量是否足够
void SLCheckCapacity(SL* s);

//管理数据————增删改查

void SLPushFront(SL* s, SLDataType x);//头插
void SLPopFront(SL* s);//头删

void SLPushBack(SL* s, SLDataType x);//尾插
void SLPopBack(SL* s);//尾删

//在pos位置插入x的值
void SLInsert(SL* s,int pos, SLDataType x);
删除pos位置
void SLErease(SL* s,int pos);

//查找位置
int SLFind(SL s, SLDataType x);

4、函数实现（SeqList.cpp)

1)初始化

void SLInit(SL* s) {
	assert(s);//检查s是否为空
	//开辟空间，malloc 
	//malloc函数包含在头文件 #include <stdlib.h>
	s->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);

	//检查空间是否开辟成功
	//s->为NULL，则开辟失败，报错
	if (s->a == NULL) {
		perror("malloc failed");//打印错误
		exit(-1);//异常方式退出，‘exit（0）’是正常退出
		//return 返回函数
		//exit 程序停止函数，推出一整个函数
	}
	s->size = 0;//存储数据个数
	s->capacity = 4;//容量
}

2)销毁

开辟额外的空间之后，一定要及时销毁！
不然会造成内存泄漏！！！

//销毁额外开辟的空间，避免内存泄漏
void SLDestroy(SL* s) {
	free(s->a);//释放空间
	s->a = NULL;//设为空
	s->capacity = s->size = 0;
}

3)打印

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

4)检查容量

void SLCheckCapacity(SL* ps)
{
	assert(s);
	// 满了要扩容
	//realloc 可以异地扩容，也可以原地扩容
	if (ps->size == ps->capacity)
	{
		//realloc  在ps->a 处扩容   
		SLDataType* tmp = (SLDataType*)realloc(ps->a, ps->capacity * (sizeof(SLDataType*)));

		if (tmp == NULL)				//检查是否扩容成功
		{
			perror("realloc failed");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}
}

5)头插、头删

A、头插图解：

代码：

//头插
void SLPushFront(SL* s, SLDataType x) {
	assert(s);

	SLCheckCapacity(s);
	for (int i = s->size; i > 0; i--)
	{
		s->a[i] = s->a[i - 1];
	}
	s->a[0] = x;
	s->size++;
}

在这里插入图片描述

B、头删 代码&图解：
//头删
void SLPopFront(SL* s) {
	assert(s);

	if (s->size == 0)
	{
		return;
	}
	int num = 0;
	while (num < s->size - 1) {//注意数组越界
		s->a[num] = s->a[num + 1];
		num++;
	}
	s->size--;
}

删除a[0],则a[0]的位置空出来了
删除a[0],则a[0]的位置空出来了

在这里插入图片描述
则紧接着移动在a[1]位置的“2”，
a[1]的位置空出来了，
则紧接着移动在a[2]位置的“3”，
在这里插入图片描述

6)尾插、尾删

//尾插
void SLPushBack(SL* s, SLDataType x)
{
	assert(s);
	SLCheckCapacity(s);
	s->a[s->size] = x;
	s->size++;
}
//尾删
void SLPopBack(SL* s) {
	assert(s);
	//温柔的检查
	/*if (s->size == 0) {
		return;
	}*/

	//暴力的检查，，断言
	assert(s->size > 0);
	s->size--;
}

7)在pos位置插入x的值

//可以被 ‘头插’‘尾插’利用
void SLInsert(SL* s, int pos, SLDataType x) {
	assert(s);
	//判断插入位置，是否合理
	if (pos < 0 || pos > s->size)
		return;

	SLCheckCapacity(s);//检查 容量
	
	int num = s->size-1 ;
	while (num>= pos)
	{
		s->a[num  +1 ] = s->a[num];
		num--;
	}
	s->a[pos] = x;
	s->size++;
}

8)删除pos位置

//删除pos位置
void SLErease(SL* s, int pos) {

	assert(s);
	if (pos < 0 || pos >= s->size)
		return;
	
	for (int i = pos ; i < s->size; i++) {
		s->a[i] = s->a[i + 1];
	}
	s->size--;
}

9)查找位置

int SLFind(SL s, SLDataType x) {

	assert(s);
for (int i = 0; i < s.size; i++) {
	if (s.a[i] == x) {
		return i;
	}
}
return -1;
}

5、代码总览

gitee链接：https://gitee.com/yan-haixuan/learning_Byte_c/tree/master/SeqList

景鹤/learning_Byte_c

（1）SeqList.h

头文件

包含的头文件：

#include <stdio.h>
#include <stdlib.h> 包含malloc realloc 函数
#include <assert.h> 暴力检查越界情况

#pragma once

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//静态数据表
//typedef int SLDataType;
//#define N 100
//struct SeqList {
//	int a[N];
//	int size;//有效数据个数
//
//}; 

//动态顺序表
typedef int SLDataType;

typedef struct SeqList {
	SLDataType* a;//指向数组的指针
	int size;	//存储数据个数
	int capacity;//开辟空间的总容量
}SL;

//函数声明
void SLInit(SL* s);//初始化

void SLDestroy(SL* s);//销毁

void SLPrint(SL* s);//打印

//检查容量是否足够
void SLCheckCapacity(SL* s);

//管理数据————增删改查

void SLPushFront(SL* s, SLDataType x);//头插
void SLPopFront(SL* s);//头删

void SLPushBack(SL* s, SLDataType x);//尾插
void SLPopBack(SL* s);//尾删

//在pos位置插入x的值
void SLInsert(SL* s,int pos, SLDataType x);
删除pos位置
void SLErease(SL* s,int pos);

//查找位置
int SLFind(SL s, SLDataType x);

（2）SeqLits.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void SLInit(SL* s) {
	assert(s);//传递，检查过来是否为空
	//开辟空间，malloc 
	s->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);
	if (s->a == NULL) {
		perror("malloc failed");//打印错误
		exit(-1);//异常方式退出，‘exit（0）’是正常退出
		//return 返回函数
		//exit 程序停止函数，推出一整个函数
	}
	s->size = 0;
	s->capacity = 4;
}

//销毁额外开辟的空间，避免内存泄漏
void SLDestroy(SL* s) {
	free(s->a);
	s->a = NULL;
	s->capacity = s->size = 0;
}

//打印
void SLPrint(SL* s)
{
	assert(s);
	for (int i = 0; i < s->size; i++) {
		printf("%d ", s->a[i]);
	}
}

void SLCheckCapacity(SL* ps)
{
	assert(s);
	// 满了要扩容
	//realloc 可以异地扩容，也可以原地扩容
	if (ps->size == ps->capacity)
	{
		//realloc  在ps->a 处扩容   
		SLDataType* tmp = (SLDataType*)realloc(ps->a, ps->capacity * (sizeof(SLDataType*)));

		if (tmp == NULL)				//检查是否扩容成功
		{
			perror("realloc failed");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}
}

//尾插
void SLPushBack(SL* s, SLDataType x)
{
	assert(s);
	SLCheckCapacity(s);
	s->a[s->size] = x;
	s->size++;
}
//尾删
void SLPopBack(SL* s) {
	assert(s);
	//温柔的检查
	/*if (s->size == 0) {
		return;
	}*/

	//暴力的检查，，断言
	assert(s->size > 0);
	s->size--;
}

//头插
void SLPushFront(SL* s, SLDataType x) {
	assert(s);

	SLCheckCapacity(s);
	for (int i = s->size; i > 0; i--)
	{
		s->a[i] = s->a[i - 1];
	}
	s->a[0] = x;
	s->size++;
}
//头删
void SLPopFront(SL* s) {
	assert(s);

	if (s->size == 0)
	{
		return;
	}
	int num = 0;
	while (num < s->size - 1) {//注意数组越界
		s->a[num] = s->a[num + 1];
		num++;
	}
	s->size--;
}

//在pos位置插入x的值 （pos是下标

//可以被 ‘头插’‘尾插’利用
void SLInsert(SL* s, int pos, SLDataType x) {
	assert(s);
	//判断插入位置，是否合理
	if (pos < 0 || pos > s->size)
		return;

	SLCheckCapacity(s);//检查 容量
	
	int num = s->size-1 ;
	while (num>= pos)
	{
		s->a[num  +1 ] = s->a[num];
		num--;
	}
	s->a[pos] = x;
	s->size++;
}
//删除pos位置
void SLErease(SL* s, int pos) {

	assert(s);
	if (pos < 0 || pos >= s->size)
		return;
	
	for (int i = pos ; i < s->size; i++) {
		s->a[i] = s->a[i + 1];
	}
	s->size--;
}

int SLFind(SL s, SLDataType x) {

	assert(s);
for (int i = 0; i < s.size; i++) {
	if (s.a[i] == x) {
		return i;
	}
}
return -1;
}

（3）Test.cpp

测试

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void TestList1() {
	SL ps;
	SLInit(&ps);

	SLPushBack(&ps, 1);
	SLPushBack(&ps, 2);
	SLPushBack(&ps, 3);
	SLPushBack(&ps, 4);
	SLPushBack(&ps, 5);
	SLPushBack(&ps, 6);

	SLPrint(&ps);

	SLDestroy(&ps);
}

void TestList2() {
	SL ps;
	SLInit(&ps);

	SLPushBack(&ps, 1);
	SLPushBack(&ps, 2);
	SLPushBack(&ps, 3);
	SLPushBack(&ps, 5);
	SLPushBack(&ps, 6);
	SLPrint(&ps);

	printf("\n");
	int x = 10;
	SLPushFront(&ps,x);

	SLPrint(&ps);

	printf("\n");
	SLPopFront(&ps);
	SLPrint(&ps);

	SLDestroy(&ps);
}

void TestList3() {
	SL ps;
	SLInit(&ps);

	SLPushBack(&ps, 1);
	SLPushBack(&ps, 2);
	SLPushBack(&ps, 3);
	SLPushBack(&ps, 4);
	SLPushBack(&ps, 5);
	
	SLPrint(&ps);

	printf("\n");

	/*int pos,x;
	printf("请输入插入的值");
	scanf("%d", &x);
	pos=SLFind(ps,x);
	SLInsert(&ps, pos, x*100);*/
	SLInsert(&ps, 1, 50);

	SLPrint(&ps);

	printf("\n");

	//删除pos位置
	SLErease(&ps, 3);

	SLPrint(&ps);

	printf("\n");
}

int main()
{
	TestList3();
	return 0;
}
景鹤
关注
  • 32
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构_顺序表(C语言)
小黯
08-07 1780
目录顺序表的基本操作创建顺序表初始化顺序表销毁顺序表置空顺序表判断顺序表是否为空取顺序表第i个数据元素查找顺序表某数据位置将某数据插入顺序表删除顺序表中某数据遍历顺序表单链表 顺序表的基本操作 创建顺序表 初始化顺序表 销毁顺序表 置空顺序表 判断顺序表是否为空 取顺序表第i个数据元素 查找顺序表某数据位置 将某数据插入顺序表 删除顺序表中某数据 遍历顺序表 单链表 ...
C语言版数据结构的线性表的底层核心代码
04-19
### C语言实现的数据结构线性表底层核心代码分析 #### 一、概述 本文将对一个用C语言实现的线性表（顺序表）的核心代码进行解析，包括其定义、创建、销毁、清空、查询长度与容量、插入、获取元素及删除元素等基本...
数据结构_线性表_双向链表（C语言实现+基本操作
m0_73726899的博客
01-29 1033
带头双向循环链表学习！！！//便于更改存储类型//存储数据元素信息//存储上一个节点信息//存储下一个节点信息} ListNode;
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
《数据结构》线性表之单链表（C语言）
Prefectkn的博客
08-03 531
本篇博客详细介绍了单链表的概念，结构，以及一些接口的实现。
【数据结构】线性表 顺序表（动态、静态分配，插入删除查找基本操作）解析+完整代码
m0_61628700的博客
02-26 837
顺序表定义用顺序存储方式实现线性表的储存。是用一组地址连续的存储单元依次存储线性表中的数据元素。特点：1.表中元素的逻辑顺序与物理顺序相同。2.可以随机存取——知道顺序表起始位置LOC(A)和每个元素所占内存的大小后，可知道任意一个元素的位置。优点1.可随机访问，O(1)时间内找到指定元素；2.存储密度高，每个结点只存储数据元素。缺点1.元素的插入和删除要移动大量数据元素。2.需要连续存储空间，不够灵活。
数据结构——顺序表（C语言实现）
2301_80485318的博客
05-01 201
一、基本概念一、基本概念概念：用一组地址连续的存储单元依次存储线性表的数据元素即顺序存储结构。特点：逻辑上相邻的数据元素，物理次序上也相邻。顺序表分为静态顺序表和动态顺序表，且在生活中常用的也是动态顺序表。这是因为静态顺序表提前开辟空间可能会导致空间开辟过多或空间不足的情况，而动态顺序表则会避免这个问题。顺序表的主要实现的就是对数据的增删查改。二、重难解析malloc函数：指针名 = (指针类型*）malloc（sizeof（指针类型）*数据数量）
C语言数据结构（线性表）顺序表的静态与动态分配增删改查
weixin_55021541的博客
10-02 390
1.静态的插入：插入操作首先需要判断插入位置i的合法性，合法性主要是位置的合法性和大小的合法性。2.动态的插入：动态的插入和静态插入本质同理，只是动态的插入在判断表的容量上是否满时不同，静态的是（L->length>=Maxsize）时候表示满，动态是（L->length>=L->maxsize）时候表示满，其中maxsize在动态初始话时候已经设置为刚开始定义的#define Initsize 10 ，但二者只是写法不同，表示的含义上是相同的，都是要插入的时候不能当前表的容量已满。
数据结构-线性表详解（类C语言版）
秃了也弱了
03-31 2059
线性表的定义和特点 线性表是具有相同特性的数据元素的一个有限序列。
【数据结构】C语言实现栈(详细解读)
weixin_65186652的博客
08-24 8922
c--数据结构,使用C语言实现栈，详细解读
李春葆编著数据结构(C语言篇)习题与解析(修订版).pdf
06-02
李春葆编著的《数据结构(C语言篇)习题与解析(修订版)》是学习这一领域的经典参考资料。 选择题1中，数据结构主要研究计算机中数据元素（A）以及它们之间的关系（B）和运算。2题中，数据结构被定义为(K, R)，其中K是...
数据结构_严蔚敏&吴伟民_C语言版
08-25
《数据结构_严蔚敏&吴伟民_C语言版》是一本非常适合初学者入门的数据结构教材，它不仅涵盖了数据结构的基本概念，还提供了丰富的实例帮助读者理解并掌握各种数据结构的实现和应用。通过学习这本书，读者不仅可以加深...
数据结构（C语言版 第2版）课后习题答案 严蔚敏 编著
01-21
顺序表是线性表的一种实现形式，通过数组来实现顺序存储的线性表。在顺序表中，元素的存储地址是连续的，每个元素的长度相同。 第三章 栈和队列 栈和队列是两种特殊的线性表，栈是一种后进先出的数据结构，队列是...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 793
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
（数据结构）二叉树
2401_83526138的博客
07-24 622
树是一种非线性的数据结构，它是由n（n>=0）个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的节点，称为根节点，根节点没有前驱节点除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1, T2, ......, Tm，其中每一个集合Ti(1 <= i <= m)又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继树是递归定义的。
【C语言】数组栈的实现
最新发布
2301_80840905的博客
07-25 746
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
数据结构——双向链表及其总结
2406_83392683的博客
07-23 345
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
线性表的顺序存储：C语言实现与解析
"本文主要介绍了线性表的顺序表示，特别是在数据结构C语言版中的实现。线性表是由一组逻辑上相邻的数据元素构成的有限序列，具有特定的逻辑特征，如每个元素有一个直接前驱或后继。文章还讨论了线性表的顺序存储结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值