数据结构--动态储存顺序表(含完整代码)

最新推荐文章于 2024-05-13 19:38:16 发布
最新推荐文章于 2024-05-13 19:38:16 发布
阅读量933 收藏 12
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65641647/article/details/127585502
版权

文章目录

💨 动态储存顺序表

💢引语

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储,即静态顺序表静态顺序表，静态顺序表我已经写好了，这次我主要来介绍 动态存储顺序表。
静态和动态的对比：静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

在这里插入图片描述

🌊顺序表的基本功能

💦1.初始化

//动态顺序存储--按需存储空间
typedef int SLDataType;   //SLDataType的类型根据实际存储的数据类型而定
typedef struct SqList
{
	SLDataType* a;  
	int size;      //记录存储多少个有效数据
	int capacity;  //空间容量的大小
}SL;

//初始化
void SLInit(SL* ps)
{
	assert(ps);    //断言，判断是否为空
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

代码解释：

  • 定义一个SLDataType类型指针a记录动态开辟的数组初始地址
  • size记录多少个有效数据，capacity为动态数组暂时性的空间大小，当size与capacity相等时，空间需要扩容。

💦2.销毁

//销毁
void SLDestroy(SL* ps)
{
	assert(ps);      //断言
	if(ps->a!=NULL)
	{
		free(ps->a);      //释放创建的动态数组
		ps->a = NULL;
		ps->size = 0;
		ps->capacity = 0;
	}
}

代码解释：
开辟的动态空间不用了要记得释放，如果不释放将导致严重后果！
如果程序结束，动态开辟的空间会被操作系统回收！
如果程序不结束，动态开辟的空间是不会被自动回收的，就会形成内存泄漏问题！
释放完的指针也要置空，不置空的话，这个指针就是野指针，如果你以后万一对这个指针进行解引用，就会造成非法访问！

💦3.打印

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

打印功能的实现比较简单，我就不做过多的赘述了

💦4.扩容

//扩容
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)  //先判断是否有空间
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

		//ps->a=(SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));  不要这样接收，扩容失败会返回空指针
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));

		if (tmp == NULL)
		{  //扩容失败
			perror("realloc fail");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newCapacity;
		}
	}
}

当size等于capacity时，动态开辟数组空间容量已经存满，需要扩容。

💦5.尾插尾删

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);  //先检查空间容量是否存满，存满需扩容
	ps->a[ps->size] = x;
	ps->size++;
}

//尾删
void SLPopBack(SL* ps)
{
	//暴力检查
	assert(ps->size > 0);
	ps->size--;
}

尾插尾删功能的测试

void TestSeqList1()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址
	SLPushBack(&sl, 1); //尾插
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPushBack(&sl, 7);
	SLPushBack(&sl, 8);
	SLPushBack(&sl, 9);
	SLPrint(&sl);

	SLPopBack(&sl); //尾删
	SLPrint(&sl);

	SLPushBack(&sl, 9);
	SLPrint(&sl);
	SLDestroy(&sl);    //用完销毁
}
int main()
{
	TestSeqList1();  //尾插功能的测试
	return 0;
}

在这里插入图片描述

💦6.头插头删

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	 assert(ps);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int begin = 0;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

头插头删功能测试

void TestSeqList2()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址
	
	SLPushFront(&sl, 1);//头插
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPrint(&sl);
	
	SLPopFront(&sl); //头删
	SLPrint(&sl);
	
	SLDestroy(&sl);

}

int main()
{
	//TestSeqList1();   //尾插尾删测试
	TestSeqList2();  //头插头删测试
	return 0;
}

在这里插入图片描述

💦7.中间插入和删除

//中间插入
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size-1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	    ps->a[pos] = x;
		ps->size++;
}

//中间删除
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	int begin = pos+1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

中间插入和删除的测试

void TestSeqList3()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLInsert(&sl, 2, 20);
	SLPrint(&sl);

	SLErase(&sl, 2);
	SLPrint(&sl);

	SLDestroy(&sl);
}

int main()
{
	//TestSeqList1();   //尾插尾删测试
	//TestSeqList2();  //头插头删测试
	TestSeqList3();    //中间插入和删除的测试
	return 0;
}

在这里插入图片描述

💦8.查找

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

查找功能的测试

void TestSeqList4()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLInsert(&sl, 2, 200);
	SLPrint(&sl);

	SLInsert(&sl, 4, 200);
	SLPrint(&sl);

	SLInsert(&sl, 0, 20);
	SLPrint(&sl);

	int pos=SLFind(&sl, 200,0); //删除数值200，开始时从下标0开始查找
	while (pos != -1)
	{
		SLErase(&sl, pos);
		pos = SLFind(&sl, 200, pos);
	}
	SLPrint(&sl);

	SLDestroy(&sl);
}

int main()
{
	//TestSeqList1();   //尾插尾删测试
	//TestSeqList2();  //头插头删测试
	//TestSeqList3();    //中间插入和删除的测试
	TestSeqList4();    //查找功能的测试
	return 0;
}

在这里插入图片描述

🌊动态顺序表的完整代码

需要创建三个文件，两个源文件，一个头文件

1.头文件SeqList.h

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

//动态顺序存储--按需存储空间
typedef int SLDataType;
typedef struct SqList
{
	SLDataType* a;
	int size;  //记录存储多少个有效数据
	int capacity;  //空间容量的大小
}SL;


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

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

//判断空间是否满了
void SLCheckCapacity(SL* ps);

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

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

//中间的插入和删除
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);

//查找
int SLFind(SL* ps, SLDataType x, int begin);

2.SeqList.c

#include "SqLList.h"

//初始化
void SLInit(SL* ps)
{
	assert(ps);    //断言，判断是否为空
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

//销毁
void SLDestroy(SL* ps)
{
	assert(ps);      //断言
	if (ps->a != NULL)
	{
		free(ps->a);      //释放创建的动态数组
		ps->a = NULL;
		ps->size = 0;
		ps->capacity = 0;
	}
}


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


//扩容
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)  //先判断是否有空间
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

		//ps->a=(SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));  不要这样接收，扩容失败会返回空指针
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));

		if (tmp == NULL)
		{  //扩容失败
			perror("realloc fail");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newCapacity;
		}
	}
}


//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);  //先检查空间容量是否存满，存满需扩容
	ps->a[ps->size] = x;
	ps->size++;
}

//尾删
void SLPopBack(SL* ps)
{
	//暴力检查
	assert(ps->size > 0);
	ps->size--;
}

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int begin = 0;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}


//中间插入
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

//中间删除
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

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

3.test.c

#include "SqLList.h"

void TestSeqList1()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址
	SLPushBack(&sl, 1); //尾插
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPushBack(&sl, 7);
	SLPushBack(&sl, 8);
	SLPushBack(&sl, 9);
	SLPrint(&sl);

	SLPopBack(&sl); //尾删
	SLPrint(&sl);

	SLPushBack(&sl, 9);
	SLPrint(&sl);
	SLDestroy(&sl);    //用完销毁
}

void TestSeqList2()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址

	SLPushFront(&sl, 1);//头插
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPrint(&sl);

	SLPopFront(&sl); //头删
	SLPrint(&sl);

	SLDestroy(&sl);

}

void TestSeqList3()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLInsert(&sl, 2, 20);
	SLPrint(&sl);

	SLErase(&sl, 2);
	SLPrint(&sl);

	SLDestroy(&sl);
}

void TestSeqList4()
{
	SL sl;
	SLInit(&sl);       //注意初始化传的是实参的地址
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLInsert(&sl, 2, 200);
	SLPrint(&sl);

	SLInsert(&sl, 4, 200);
	SLPrint(&sl);

	SLInsert(&sl, 0, 20);
	SLPrint(&sl);

	int pos = SLFind(&sl, 200, 0); //删除数值200，开始时从下标0开始查找
	while (pos != -1)
	{
		SLErase(&sl, pos);
		pos = SLFind(&sl, 200, pos);
	}
	SLPrint(&sl);

	SLDestroy(&sl);
}

int main()
{
	//TestSeqList1();   //尾插尾删测试
	//TestSeqList2();  //头插头删测试
	//TestSeqList3();    //中间插入和删除的测试
	TestSeqList4();    //查找功能的测试
	return 0;
}

在这里插入图片描述

痴☞
关注
  • 18
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
【数据结构】-串的顺序存储(动态分配）
RunningSnail的博客
08-03 1954
串的堆分配存储-动态分配1.头文件及类型定义2.串类型定义3.函数声明4.基本操作4.1 初始化串4.2 增加串的长度4.3 求串长4.4 清空4.5 判空4.6 赋值操作★4.7 复制操作★4.8 联接操作★4.9 求子串操作★★4.10 比较操作★★4.11 定位操作★★★4.12 销毁操作4.13 遍历4.14 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdlib.h> #define MAXLEN 10 //预定义
数据结构——线性表的顺序存储（静态分配）
jasmoyn的博客
04-04 443
数据结构 线性表的顺序存储（静态分配） 跟着王道学习数据结构，边学边打代码。 //顺序表的静态分配 #include<stdio.h> #define maxsize 50 //定义顺序表的最大数据存储量 //创建表 typedef struct{ int x[maxsize];// int length;//记录表长 }sqlist; //初始化 void initlist(sqlist &L){ L.length=0; printf("初始化成功\n"); }
动态表单的数据存储
weixin_52703987的博客
04-14 2万+
动态表单的数据存储 这里根据上面的动态表单设计的界面，整合并存储对应界面控件的值，从而实现了动态表单和动态表单数据的整合显示了。 为了有效管理动态表单的数据和是否展示的处理，我们在业务表单的data属性集合中增加了两个变量，如下所示。 hasDynamicForm: false, // 是否有动态表单 dynamicFormJson: '', // 动态表单的JSON数据 这样我们在业务表单列表界面呈现的时候，也同时获取对应的动态界面结构JSON，如下代码所示。 created() { t
顺序表（动态存储）的基本操作
gaokuiyuan的博客
07-23 392
顺序表的动态分配，main函数采用接口输出实现。
数据结构与算法学习笔记二---顺序表的动态存储表示和实现(C语言)
最新发布
我叫柱子哥
05-13 296
这篇博客主要是顺序表的动态分配存储表示。
使用动态表单接收与存储信息
实鼠不疫,牛转乾坤
11-28 6530
之前，我们已经分析了如何在页面对动态表单进行显示。表单显示出来了，那么接下来我们就需要将动态表单中的信息保存到数据库。 在此，我们再次明确一下动态表单的使用的条件：假设现在有多条流程，每一条流程都需要不同形式的表单。                      这里，我们分成两大步：为该流程添加所需的动态表单和将动态表单中数据存储到数据库 1、为某项流程添加特定的动态表单 首先，是页面
数据结构——（8）动态存储管理
DF10f-0001A
11-14 1236
一、概述 1、占用块 占用块：已分配给用户使用的地址连续的内存区 可利用空间块：未曾分配的地址连续的内存区 2、动态存储分配过程的内存状态 二、可利用空间表及分配方法 可利用空间表也称为存储池。 1、可利用空间表的三种不同结构形式 系统运行期间所有用户请求分配的存储量大小相同。对此类系统，在系统开始运行时将它使用的内存区按所需大小分割成若干大小相同的块，然后用指针链接成一个可利用空间表。因为表中节点的大小相同，则分配时无需查找，只要将表中的第一个节点分配给用户即可；同样，当用户释放内存
c语言 顺序表的基本操作（创建、初始化、赋值、插入、删除、查询、替换、输出）
热门推荐
songbai220
08-18 3万+
c语言 顺序表的基本操作（创建、初始化、赋值、插入、删除、查询、替换、输出） 1、创建、申请空间 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据，后续数据循环后移，长度增加，空间大小增加或者不变 5、删除、删除指定位置的数据，后续数据循环前移，长度减小、空间大小不变 6、查询、查看指定数据是否在顺序表结构中 7、替换、将顺序表结构中指...
数据结构与算法实验（C++）：顺序表实验-代码
01-18
1） 熟练掌握顺序表的存储特点； 2） 熟练掌握顺序表的基本算法：例如插入、删除、按值或按序号查找、输出等；并拓展一些操作算法，例如置逆、按值删除等； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用顺序表...
数据结构学习--线性表及其应用--顺序表
06-25
通过这样的实验，学习者能够更好地理解顺序表的特性和基本操作，为后续学习更复杂的数据结构如树、图等打下坚实的基础。同时，对顺序存储结构的熟悉也有助于提升对数组、指针等基础知识的运用能力。在实际编程中，...
顺序表C++_数据结构实验--顺序表；C++语言_
09-30
实验1可能涵盖以上所述内容，通过编写和调试代码，你可以实际体验顺序表的操作过程，加深对数据结构的理解。此外，实验还可能涉及性能分析、错误处理和代码优化，这些都是软件开发中不可或缺的技能。通过实践，你将...
数据结构2-线性表之顺序储存（顺序表）C语言版
10-21
本主题将深入探讨“数据结构2-线性表之顺序储存（顺序表）C语言版”，这是一段用C语言实现的顺序表的数据结构。顺序表是线性表的一种基本存储方式，它将元素存储在一块连续的内存区域中，通过数组来实现。 顺序表的...
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
本压缩包包含的代码专注于顺序表，这是最基础也是最常见的数据结构之一。 顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的...
构造线性表之顺序表并对其进行初始化，追加，遍历（C语言实现）（一）
m0_75148210的博客
01-09 1396
构造线性表之顺序表并对其进行初始化，追加，遍历（C语言实现） 定义：顺序表是指用一组地址连续的存储单元依次存储线性表的数据元素的一种存储结构。特点：逻辑上相邻的数据元素，其物理次序也是相邻的。顺序表便于存取元素，这个优点取决于他的顺序存储结构。但它也有其缺点，就是不便于插入和删除元素，如果想便于插入和删除元素，则需要链式存储结构。让我们以后再谈论这些数据结构吧！
C语言实现顺序表（动态）
2301_76269963的博客
03-06 1136
C语言实现顺序表（动态）
数据结构之顺序表动态
yh971660526的博客
08-14 226
顺序表动态 头文件SeqListD.h 源文件SeqListD.c 头文件SeqListD.h #pragma once #include &lt;stdlib.h&gt; #include &lt;assert.h&gt; #include &lt;stdio.h&gt; typedef int DataType; struct SeqListDynamic { DataTyp...
【数据结构Note1】- 顺序表
weixin_63267854的博客
04-27 1978
线性表得顺序存储实现，动态分配空间实现顺序表，顺序表实现雷区
C语言数据结构——动态顺序表
刘先生倒了u的博客
07-13 508
动态顺序表与静态顺序表的区别在于结构体的定义以及初始化 一、头文件与宏定义 标准输入输出头文件 ElemType定义为元素类型int 顺序表静态分配空间长度为6 #include<stdio.h> #define ElemType int #define MAXSIZE 6 二、结构体定义 一个存放元素的数组，长度为MAXSIZE 存放长度为len，len可以随着插入数据而改变 typedef struct{ ElemType *data; //数据指针 int ma.
动态顺序表的C语言实现（详细）
qq_983030560的博客
11-28 2122
顺序表的C语言实现

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

痴☞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值