详解动态顺序表

已于 2024-01-06 21:53:48 修改
阅读量903 收藏 40
点赞数 42
分类专栏： 数据结构 文章标签： javascript 开发语言 ecmascript
于 2024-01-02 12:09:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X_do_myself/article/details/135329170
版权

𝙉𝙞𝙘𝙚!!👏🏻‧✧̣̥̇‧✦👏🏻‧✧̣̥̇‧✦ 👏🏻‧✧̣̥̇:Solitary-walk

      ⸝⋆   ━━━┓
     - 个性标签 - ：来于“云”的“羽球人”。 Talk is cheap. Show me the code
┗━━━━━━━  ➴ ⷯ

本人座右铭 ：   欲达高峰,必忍其痛;欲戴王冠,必承其重。

👑💎💎👑💎💎👑 
💎💎💎自💎💎💎
💎💎💎信💎💎💎
👑💎💎　💎💎👑    希望在看完我的此篇博客后可以对你有帮助哟

👑👑💎💎💎👑👑   此外，希望各位大佬们在看完后，可以互赞互关一下，看到必回
👑👑👑💎👑👑👑     

目录 

一：顺序表的介绍

  1：顺序表定义

    顺序表是线性表的一种，首先顺序表是是用一段物理地址连续的存储单元依次存储数据元素的线性结构，多数情况下借助数组来存储

二：动态顺序表和静态顺序表区别

  1：静态顺序表：

   静态就体现了静态顺序表的特征，数组的空间大小是固定的

//静态顺序表的结构体的构造
#define N 10
typedef int SLDataTYpe;//便于实现各种数据类型，一改全改

typedef struct SeqList
{
	SLDataTYpe a[N];
	int size;//记录数据有效的个数
}SL;
 2：动态顺序表

 动态体现了是一个不断变化的过程，可以频繁进行扩容

//动态顺序表
typedef int SLDataType;//便于实现各种数据类型，一改全改
typedef struct SeqList
{
	SLDataType* a;
	int size;//记录数据有效的个数
	int capacity;//空间空间的容量
}SL;
3：二者区别

静态顺序表：以定长数组的形式存储

动态顺序表：以动态开辟的数组进行存储

本质上二者没有优劣之分，只不过动态顺序表多了一个成员：空间容量

三：动态顺序表的接口实现

1. 初始化

为了避免不必要的麻烦，我们在初始化的时候直接就对数组进行动态开辟

void SLInit(SL* psl)
{
	assert(psl);
	psl->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);//先为数组开4 个空间
	if (psl->a == NULL)  //空间检查
	{
		printf("perror malloc\n");
		return;
	}
    // 开辟成功
	psl->size = 0;
	psl->capacity = 4;
}
2.销毁
void SLDestroy(SL* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = 0;
	psl->size = 0;
}
3.尾插

分析：首先我们在尾插之前需要先进行空间容量检查

 

void SLPushBack(SL* psl, SLDataType x)
{
	assert(psl);
	//先判断空间是否足够
	CheckCapacity(psl);
	//之后直接尾插
	psl->a[psl->size] = x;
	psl->size++;
}
4.头插

分析：

1）空间容量的检查

2） 数据的挪动：从后往前挪动（避免数据覆盖）

3）下标边界值的确定

 

void SLPushFront(SL* psl, SLDataType x)
{
	assert(psl);
	//先判断空间是否足够
	CheckCapacity(psl);
	 挪动数据：从后往前挪动数据 注意边界的问题
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[0] = x;

	
	 psl->size++;
}
 5.尾删

先进行判空，其次直接size--

void SLPopBack(SL* psl)
{
	assert(psl);
	//判断是否为空   温柔  / 暴力判断
	 if (psl->size == 0)
	{
		printf("为空 \n");
		return;
	}
	
	psl->size--;

}
6.头删

先进行判空

其次挪动数据：从前往后挪动

下标边界的确定

 

void SLPopFront(SL* psl)
{
	assert(psl);
	assert(psl->size);//判空
	// 挪动数据：从前往后挪数据
	int start = 0;
	while (start < psl->size - 1)
	{
		psl->a[start] = psl->a[start + 1];
		start++;
	}
	//SLEarse(psl, 0);
	//注意：别忘了size--
	psl->size--;


}
7.任意位置的插入

1）空间容量检查

2）pos这个位置是否合法

3）数据挪动：和头插一样

 

void SLInsert(SL* psl, int pos, SLDataType x)
{
	assert(psl);
	// 先进行空间判断，以及位置的合法

	CheckCapacity(psl);
	
	assert(pos >= 0 && pos <= psl->size);  //这里可以取等，因为数组下标是连续的，可以在psl->size 这个位置插入
	
	int i = psl->size - 1;
	while (i >= pos)
	{
		psl->a[i + 1] = psl->a[i];
		i--;
	}
	psl->a[pos] = x;
	psl->size++;
	// 灵活运用： 头插，尾插就是此函数的一个特列

}
8.任意位置的删除

1）判空检查

2）pos是否合法

3）数据挪动：同头删一样

 

void SLEarse(SL* psl, int pos)
{
	assert(psl);
	//删除之前，先对pos这个位置判断是否合法，是否为空
	assert(pos >= 0 && pos < psl->size);  //注意这里没有必要取等  ，同时这个语句暗含着对判空的操作了
	int i = pos;
	//挪动数据：从前往后
	while (i < psl->size - 1)
	{
		psl->a[i] = psl->a[i + 1];
		i++;
	}
	//别忘了 size--

	psl->size--;

}

9.空间容量的检查

    当我们在进行头插，尾插，任意位置插入时都需要进行空间容量的检查，这里为了避免不必要的麻烦，写了一个函数

void CheckCapacity(SL* psl)
{
	assert(psl);
	if (psl->capacity == psl->size)
	{
		//realloc来扩容   void* realloc (void* ptr, size_t size);  第二个参数：扩容之后新的空间字节数，而不是要增加的字节数
		// 注意这样写是错误的，在free 的时候有问题  SLDataType* tmp = (SLDataType*)realloc(psl->a, (sizeof(SLDataType) *  4) * 2);//以原来2倍空间扩容
		SLDataType* tmp = (SLDataType*)realloc(psl->a, (sizeof(SLDataType) * psl->capacity) * 2);//以原来2倍空间扩容
		if (tmp == NULL)
		{
			printf("perror realloc\n");
			return;
		}
		// 扩容成功,进行更新
		psl->a = tmp;
		psl->capacity *= 2;

	}
}
10. 查找

1）前期的判断：位置是否合法？  顺序表是否为空表

2） 其实就是暴力求解，依次遍历顺序表即可，若是找到返回下标，找不到返回-1

int  SLFind(SL* psl, SLDataType x)//查找
{
	assert(psl);
	assert(psl->size);//避免为空
	int i = 0;
	while (i < psl->size)
	{
		if (psl->a[i] == x)
		{
			return i;// 返回下标
		}
		i++;
	}
	return -1;//没有找到
}

11.任意位置修改 

1）依然是老生常谈，对位置以及顺序表进行判断

2）直接进行修改

void SLModify(SL* psl, int pos, SLDataType x) //指定位置修改
{
	assert(psl);
	assert(psl->size);//避免为空
	assert(pos >= 0 && pos <= psl->size - 1);
	psl->a[pos] = x;

}

完整代码：

SeqList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

void SLInit(SL* psl)
{
	assert(psl);
	psl->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);//先为数组开4 个空间
	if (psl->a == NULL)
	{
		printf("perror malloc\n");
		return;
	}
	psl->size = 0;
	psl->capacity = 4;
}
void SLDestroy(SL* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = 0;
	psl->size = 0;
}
void CheckCapacity(SL* psl)
{
	assert(psl);
	if (psl->capacity == psl->size)
	{
		//realloc来扩容   void* realloc (void* ptr, size_t size);  第二个参数：扩容之后新的空间字节数，而不是要增加的字节数
		// 注意这样写是错误的，在free 的时候有问题  SLDataType* tmp = (SLDataType*)realloc(psl->a, (sizeof(SLDataType) *  4) * 2);//以原来2被空间扩容
		SLDataType* tmp = (SLDataType*)realloc(psl->a, (sizeof(SLDataType) * psl->capacity) * 2);//以原来2被空间扩容
		if (tmp == NULL)
		{
			printf("perror realloc\n");
			return;
		}
		// 扩容成功,进行更新
		psl->a = tmp;
		psl->capacity *= 2;

	}
}
void SLPushBack(SL* psl, SLDataType x)
{
	assert(psl);
	//先判断空间是否足够
	CheckCapacity(psl);
	//之后直接尾插
	/*psl->a[psl->size] = x;
	psl->size++;*/
	if (psl->size == 0)
	{
		psl->a[psl->size] = x;
		psl->size++;
	}
	else
	{
		SLInsert(psl, psl->size, x);
		//注意这里不用size++，因为SLInsert这个函数以及涉及到了
	}
}
void SLPushFront(SL* psl, SLDataType x)
{
	assert(psl);
	//先判断空间是否足够
	CheckCapacity(psl);
	 挪动数据：从后往前挪动数据 注意边界的问题
	//int end = psl->size - 1;
	//while (end >= 0)
	//{
	//	psl->a[end + 1] = psl->a[end];
	//	end--;
	//}
	//psl->a[0] = x;

	SLInsert(psl, 0, x);
	// psl->size++;
}
void SLPopBack(SL* psl)
{
	assert(psl);
	//判断是否为空   温柔  / 暴力判断
	 /*if (psl->size == 0)
	{
		printf("为空 \n");
		return;
	}*/
	assert(psl->size);
	psl->size--;

}
void SLPopFront(SL* psl)
{
	assert(psl);
	assert(psl->size);//判空
	// 挪动数据：从前往后挪数据
	int start = 0;
	while (start < psl->size - 1)
	{
		psl->a[start] = psl->a[start + 1];
		start++;
	}
	//SLEarse(psl, 0);
	//注意：别忘了size--
	psl->size--;


}
void SLPrint(SL* psl)
{
	assert(psl);
	int i = 0;
	while (i < psl->size)
	{
		printf("%d ", psl->a[i]);
		i++;
	}
	printf("\n");
}
void SLEarse(SL* psl, int pos)
{
	assert(psl);
	//删除之前，先对pos这个位置判断是否合法，是否为空
	assert(pos >= 0 && pos < psl->size);  //注意这里没有必要取等  ，同时这个语句暗含着对判空的操作了
	int i = pos;
	//挪动数据：从前往后
	while (i < psl->size - 1)
	{
		psl->a[i] = psl->a[i + 1];
		i++;
	}
	//别忘了 size--

	psl->size--;

}
void SLInsert(SL* psl, int pos, SLDataType x)
{
	assert(psl);
	// 先进行空间判断，以及位置的合法

	CheckCapacity(psl);
	
	assert(pos >= 0 && pos <= psl->size);  //这里可以取等，因为数组下标是连续的，可以在psl->size 这个位置插入
	
	int i = psl->size - 1;
	while (i >= pos)
	{
		psl->a[i + 1] = psl->a[i];
		i--;
	}
	psl->a[pos] = x;
	psl->size++;
	// 灵活运用： 头插，尾插就是此函数的一个特列

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

//顺序表分类：静态顺序表  动态顺序表
 
//静态的：空间开大了浪费，空间开小了不够用


/*静态顺序表的结构体的构造
#define N 10
typedef int SLDataTYpe;//便于实现各种数据类型，一改全改

typedef struct SeqList
{
	SLDataTYpe a[N];
	int size;//记录数据有效的个数
}SL;
*/

//动态顺序表
typedef int SLDataType;//便于实现各种数据类型，一改全改
typedef struct SeqList
{
	SLDataType* a;
	int size;//记录数据有效的个数
	int capacity;//空间空间的容量
}SL;
//接口函数的实现

void SLInit(SL* psl);
void SLDestroy(SL* psl);
void SLPushBack(SL* psl, SLDataType x);
void SLPushFront(SL* psl, SLDataType x);
void SLPopBack(SL* psl);
void SLPopFront(SL* psl);
void SLPrint(SL* psl);
void SLEarse(SL* psl,int pos);
void SLInsert(SL* psl, int pos, SLDataType x);

结束语：

以上就是我今日要为大家分享的，希望各位大佬随时指正，咱一波关注走起，看到必回

Solitary_walk
关注
  • 42
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
静态顺序表和动态顺序表区别
yy_1121的博客
03-12 1697
静态顺序表和动态顺序表区别
【数据结构】- 顺序表详解(动图演示！！！！）
success
08-23 767
顺序表(SeqList)是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
动静态顺序表
weixin_62981548的博客
05-13 345
大家都知道要学好编程，数据结构是十分重要的一门课，而线性表是一种在实际中广泛使用的数据结构，那么线性表是什么呢，线性表是n个具有相同特性（数据类型）的数据元素的有限序列，常见的线性表有：顺序表、链表、栈、队列、字符串…但不要误会的是线性表在逻辑上是线性结构，也就是一条连续的直线，但在物理结构上不一定是连续的，所以线性表在物理上存储时，通常以数组和链式结构形式存储，下面我们就来学习一下线性表中的顺序表吧。
【数据结构和算法】实现线性表中的静态、动态顺序表
小王学代码
01-25 1224
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。我们本文讲解了，线性表中的顺序表的使用，我们分别实现了静态和动态的顺序表，这是数据结构的基础，我们接下来讲解的内容是线性表中的链表。
顺序表操作（动态+静态版本），思路清晰易懂
Javaxaiobai的博客
10-28 871
帮助新手学习有关顺序表的知识，讲解现实思路以及代码实现，附源码。
『初阶数据结构 • C语言』⑧ - 动态顺序表详解（附完整源码）
花想云的博客
01-13 1421
上一章我们学习了静态顺序表的增删查改，并认识了静态顺序表的存储结构与静态顺序表的在不同场景下的优劣。静态顺序表与动态顺序表都叫做顺序表，只不过我们平时口头所提的顺序表指的是动态顺序表。
C语言实现静态顺序表的实例详解
01-01
C语言实现静态顺序表的实例详解 线性表 定义一张顺序表也就是在内存中开辟一段连续的存储空间，并给它一个名字进行标识。只有定义了一个顺序表，才能利用该顺序表存放数据元素，也才能对该顺序表进行各种操作。 接...
顺序表的基本操作详解.zip
03-20
顺序表的基本操作详解
Python中顺序表原理与实现方法详解
09-18
主要介绍了Python中顺序表原理与实现方法,结合实例形式分析了Python顺序表的概念、原理及增删查等相关实现技巧,需要的朋友可以参考下
什么是Python中的顺序表
09-16
在本篇文章里小编给大家整理了一篇关于Python中顺序表详解的相关知识点以及实例内容，需要的朋友们可以参考下。
动态顺序表相对于静态顺序表变了些什么？
shy_black的博客
09-18 221
head.h #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;assert.h&amp;gt; #include&amp;lt;string.h&amp;gt; #define DataType int #define MAX 50 typedef struct SeqList { DataType
【数据结构】动态顺序表和静态顺序表的对比(C语言)
Qingmou's_blog
09-19 1968
静态顺序表的定义 #define MAX_SIZE (100) typedef int DataType; typedef struct SeqList { DataType data[MAX_SIZE]; int size; } SeqListR; 动态顺序表的定义 typedef int DDataType; typedef struct { DDataTyp...
【数据结构】静态、动态顺序表
cottonrose_orange的博客
09-11 534
静态顺序表 顺序表的初始化和销毁 打印顺序表 查找 二分查找 增加数据 尾插 头插 在指定位置插入 删除数据 尾删 头删 指定位置删除（下标删除） 指定元素删除（数据删除） 删除所有指定元素 顺序表属性 排序 冒泡排序 选择排序 动态顺序表 顺序表的初始化和销毁 顺序表的打印 增加数据 静态与动态的比较 静态顺序表 数据类型的定义 ...
静态顺序表和动态顺序表 对比
jhcconan614的博客
12-30 1619
静态顺序表的缺陷：静态顺序表显然就是里面的内存是一定的，不能改变的，所以定义的时候可以定义一个宏，然后定义一个数组，这样就可以在数组中存储信息，而且，还可以随时改变数组的大小。typedef int DataType; #define MaxSize 10typedef struct SeqList { DataType array[MaxSize]; size_t size;
[Vue-常见错误]浏览器显示Uncaught runtime errors
一个喜欢什么都研究一下的小小后端程序员
06-09 330
在vue.config.js中配置关闭Uncaught runtime errors显示。
JS中一个dom元素能绑定多少事件
ggq53219的博客
06-10 505
在JavaScript中，一个DOM元素可以绑定的事件数量并没有明确的限制，这主要取决于浏览器的实现和内存限制。然而，在实际应用中，为同一个DOM元素绑定过多的事件监听器可能会导致性能问题，尤其是在事件处理函数执行复杂操作的情况下。总之，虽然JavaScript中DOM元素可以绑定的事件数量没有明确的限制，但在实际应用中应注意避免过度绑定和优化事件处理函数，以确保良好的性能和用户体验。
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1214
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
vue3如何定义一个组件
Java程序员专栏
06-09 521
注意在子组件的 <template> 中，你使用 {{ propName }} 来显示传递进来的参数值。在父组件中，你使用 :propName="parentMessage" 来将 parentMessage 数据的值绑定到子组件的 propName prop 上。当使用 <script setup> 语法糖时，你不能直接在 <script> 标签内使用 props 选项。在 Vue 3 中，定义一个可以接收参数的组件通常是通过在组件的 props 选项中定义这些参数来完成的。// 其他组件逻辑...
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
最新发布
lx_nhs的博客
06-12 414
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
动态数组顺序表初始化c++
07-27
动态数组的顺序表初始化可以通过使用new关键字来创建数组，并使用花括号{}来初始化数组元素。例如，可以使用以下代码来初始化一个动态数组的顺序表： int* array = new int\[5\]{1, 2, 3, 4, 5}; 这将创建一个包含...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值