动态顺序表(动态扩容)

最新推荐文章于 2024-08-01 13:58:41 发布
最新推荐文章于 2024-08-01 13:58:41 发布
阅读量964 收藏 14
点赞数 21
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80064645/article/details/140829501
版权

动态顺序表

经过以上分析，在程序运行的过程中，静态顺序表的表容量是不可修改的，导致存储空间有时会不够用，也有时会空余比较多，我们更希望可以有动态申请的空间的方法，实现顺序表容量的动态化。

C语言/C++ 中提供了动态申请空间的库函数(malloc)关键字(new)，因此我们可以利用他们实现顺序表的动态化

此处使用C语言的malloc函数

类型定义

#include <iostream>
#include <assert.h>
#include <stdlib.h>
#define InitSize 10//默认最大长度
typedef struct {
	int MaxSize;	//顺序表的最大容量
	int length;		//顺序表的当前长度
    int* data;		//指向动态分配数组的指针
}SeqList;

由于malloc函数返回的是所申请空间的地址，因此我们需要用指针来接受，还是那句话，为了方便起见，我们用 int* 来接收

初始化

void InitList(SeqList& L) {
	L.data = (int*)malloc(sizeof(int) * InitSize);	//指向动态申请的空间
	assert(L.data);
	L.length = 0;									//未加入数据前，初始长度为0
	L.MaxSize = InitSize;							//设置最大长度
}

我们传入了相应顺序表的引用，引用可以规避函数形参的二级指针，这点还是很方便的。
assert 断言函数，当申请空间失败时，该函数可以帮助我们抛出异常，此函数再之后的文章中会经常出现。
申请完空间后，此时的数组还未存储数据，因为我们设定当前容量为0 ，并且规定数组的最大长度为初设设定的长度。
在这里插入图片描述
读到这里，读者不难发现一些问题。初始化时，只不过是将申请的内存放在了堆区，数组的大小依然是预先设置好的，并不能实现运行过程中的动态内存。这便是接下来要讨论的问题。

动态内存，那我们就要充分利用动态，我们可以在程序的运行过程中动态的给数组进行扩容。通过 if 语句判断当前的容量是否超标，然后进行扩容。

扩容与插入

一般情况下，扩容往往是在插入元素时发生的。

扩容函数

//动态给顺序表扩容
void IncreaseLen(SeqList& L, int len) {
	int* p = L.data;
	L.data = (int*)malloc(sizeof(int)* (len+L.MaxSize));
	assert(L.data);
	//转移元素
	for (int i = 0; i < L.length; i++) {
		L.init[i] = p[i];
	}
	p = NULL;
	free(p);
	L.MaxSize = L.MaxSize + len;
}

我们先用p指针记录下之前空间的地址，然后再用malloc函数申请一块更大的空间，参数len接收的是要增大的容量。扩容后，要将原来空间内的元素转移到新的空间中，再将原来的堆区的空间释放掉，在这里插入图片描述

最后标记数组的最大空间已改变在这里插入图片描述
有了扩容函数，我们便可以配合插入函数来使用
由于插入后需要移动大量的元素，该操作经常使用，我们可以将其抽象成一个函数来经常调用。

元素移动后，直接插入 ele即为待插入的元素

插入

void Insertele_1(SeqList& L, int i, int ele) {//将第i个及其后面的元素后移 j从最后一个元素(下标为length-1)开始
	for (int j = L.length-1; j >= i - 1; j--)	// 需要移动的最后一个元素的下标为(i-1)
		L.data[j + 1] = L.data[j];
	L.data[i-1] = ele;	//第i个元素的数组下标为 i-1
	L.length++;
}
//在顺序表的 第 i 个位置上插入一个元素
bool Insertele_2(SeqList& L, int i, int ele) {
	if (i<1 || i>L.length + 1)
		return false;
	if (L.length == L.MaxSize) {
		IncreaseLen(L, 1);
		Insertele_1(L, i, ele);
		return true;
	}
	Insertele_1(L, i, ele);
	return true;
}

此时，Insertele_2 函数(实现插入功能)的结构就十分清晰了

  • 判断要插入的位置是否合法
  • 判断数组的容量是否满了， 满了就扩容(调用扩容函数)后再插入(调用实现插入操作的函数)
  • 未满的话直接插入

该数组的空间是由我们程序员动态分配的，因此可以多出一些小操作，例如销毁。

小操作

//销毁线性表
void DestroySqList(SeqList& L) {
	if (L.data)
		free(L.data);
}
// 清空线性表
void ClaerSqList(SeqList& L) {
	L.length = 0;
}
//求线性表长度
int GetLength(SeqList& L) {
	return L.length;
}
//判断是否非空
bool EmptyJudge(SeqList& L) {
	if (L.length)
		return false;
	return true;
}
//获取线性表中 第i个元素   函数直接返回第 i 个元素
int Getele(SeqList& L, int i) {
	if (i < 1 || i>L.length)
		return -1;
	return L.data[i - 1];
}

以上操作原理和实现较为容易，此处不再赘述。

删除和遍历

//删除顺序表上第 i 个元素   并返回
bool Delele(SeqList& L, int i, int& ele) {
	if (i<1 || i>L.length)
		return false;
	ele = L.data[i - 1];
	for (int j = i-1; j <= L.length-1; j++) {
		L.data[j] = L.data[j+1];
	}
	L.length--;
    return true;
}

//遍历顺序表
void printSqlist(SeqList& L) {
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");
}

动态顺序表和静态顺序表的增删查改区别并不大，不同的就是动态顺序表在插入的时候可以添加扩容函数从而实现数组长度的动态化。

动态和静态的优缺点都是相同的，详情可以看上篇文章，这里简单提到。

优点

  • 存储密度大(数据本身的存储空间/结点所占的存储空间)
  • 随机访问 我们在访问表中的元素时只需传入值或者位序即可，访问速度较快

缺点

  • 在插入，删除相应的元素时，需要移动大量的元素，插入和删除操作的时间复杂度较高。
  • 静态存储，初始化的表的大小难以更改，数据元素的更熟不能任意扩充。

综合优缺点，顺序表适合存储元素数量相对固定，访问较多，而插入和删除较少的线性数据类型。

所有代码

#include <iostream>
#include <assert.h>
#include <stdlib.h>
#define InitSize 10//默认最大长度
typedef struct {
	int MaxSize;	//顺序表的最大容量
	int length;		//顺序表的当前长度
    int* data;		//指向动态分配数组的指针
}SeqList;

void InitList(SeqList& L) {
	L.data = (int*)malloc(sizeof(int) * InitSize);	//指向动态申请的空间
	assert(L.data);
	L.length = 0;									//未加入数据前，初始长度为0
	L.MaxSize = InitSize;							//设置最大长度
} 

//动态给顺序表扩容
void IncreaseLen(SeqList& L, int len) {
	int* p = L.data;
	L.data = (int*)malloc(sizeof(int)* (len+L.MaxSize));
	assert(L.data);
	//转移元素
	for (int i = 0; i < L.length; i++) {
		L.init[i] = p[i];
	}
	p = NULL;
	free(p);
	L.MaxSize = L.MaxSize + len;
}

void Insertele_1(SeqList& L, int i, int ele) {//将第i个及其后面的元素后移 j从最后一个元素(下标为length-1)开始
	for (int j = L.length-1; j >= i - 1; j--)	// 需要移动的最后一个元素的下标为(i-1)
		L.data[j + 1] = L.data[j];
	L.data[i-1] = ele;	//第i个元素的数组下标为 i-1
	L.length++;
}
//在顺序表的 第 i 个位置上插入一个元素
bool Insertele_2(SeqList& L, int i, int ele) {
	if (i<1 || i>L.length + 1)
		return false;
	if (L.length == L.MaxSize) {
		IncreaseLen(L, 1);
		Insertele_1(L, i, ele);
		return true;
	}
	Insertele_1(L, i, ele);
	return true;
}

//销毁线性表
void DestroySqList(SeqList& L) {
	if (L.data)
		free(L.data);
}
// 清空线性表
void ClaerSqList(SeqList& L) {
	L.length = 0;
}
//求线性表长度
int GetLength(SeqList& L) {
	return L.length;
}
//判断是否非空
bool EmptyJudge(SeqList& L) {
	if (L.length)
		return false;
	return true;
}
//获取线性表中 第i个元素   函数直接返回第 i 个元素
int Getele(SeqList& L, int i) {
	if (i < 1 || i>L.length)
		return -1;
	return L.data[i - 1];
}

//删除顺序表上第 i 个元素   并返回
bool Delele(SeqList& L, int i, int& ele) {
	if (i<1 || i>L.length)
		return false;
	ele = L.data[i - 1];
	for (int j = i-1; j <= L.length-1; j++) {
		L.data[j] = L.data[j+1];
	}
	L.length--;
    return true;
}

//遍历顺序表
void printSqlist(SeqList& L) {
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");
}

如果本文对你有帮帮助，还请点赞收藏哦！

一匹电信狗
关注
专栏目录
顺序表的实现
m0_64240499的博客
07-28 325
C语言实现顺序表
顺序表（动态扩容）
m0_69886881的博客
09-01 469
含：顺序表的实现代码C语言版，每个相关函数的介绍
顺序表--动态内存分配
qq_44805233的博客
05-28 889
1、空指针（NULL）。不给指针分配物理内存空间。 2、野指针：区别于空指针，只是简单的定义的指针的类型，并没有给指针分配属于他自己的内存空间，此时的指针随机指向内存中的一段空间。 3、当我们给野指针分配内存后，或者让他指向某一段静态的内存，这时的指针有了自己的内存，不在是野指针。 动态分配内存 在C语言中，我们常常通过malloc函数为一个野指针分配内存。 int *p;//没有为指针分配内存，此时的指针我们称之为野指针。 p = (int *)malloc(sizeof(int )*Max_siz
【数据结构与算法】基于动态内存分配的顺序表构造算法 C++实现（顺序表+动态内存分配）
最新发布
HEX9CF的技术博客
08-01 641
设计一个算法，依次读入数组A[m]中的数据，创建一个用动态存储分配构造的顺序表L。注： L的类型定义为SqList。
顺序表（动态分配内存
悔惜晟
04-16 1127
#include// 顺序表（动态分配内存）2010-04-16 11:29:34#include#include//#include#include// 用来清屏using namespace std;const int list_size = 1000;const int list_SIZE = 10;typedef struct { int *elem; // 存储空间基址 int le
C语言实现动态顺序表的实现代码
08-29
本文主要介绍了C语言实现动态顺序表的实现代码，动态顺序表是指在内存中开辟一块空间，可以随我们数据数量的增多来扩容的线性表。下面将详细介绍动态顺序表的实现代码。 一、顺序表的基本概念 顺序表是在计算机...
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的数组，而动态顺序表则可以根据需要动态地调整其容量。 静态顺序表的优点在于...
数据结构动态顺序表.zip
02-04
动态顺序表的核心在于数组的动态扩容。在初始阶段，我们可以定义一个较小的数组，当数组容量不足时，我们需要创建一个新的、更大的数组，并将旧数组中的元素复制到新数组中。这种扩容过程称为“动态重分配”。VS2013...
如何实现顺序表的动态扩容
**介绍顺序表和动态扩容** 顺序表是一种基本的数据结构，通过一组连续的存储单元来存储数据元素。然而，静态顺序表在使用过程中存在容量固定、内存浪费、插入删除困难等问题。为了解决这些问题，引入了动态扩容的...
顺序表的存储结构（动态）
木辛木又
01-17 8248
顺序表的存储结构（动态） 在建立顺序表时，除了预先申请内存空间，还需要实时记录顺序表的长度和顺序表本身申请的内存大小，便于后期对顺序表中的数据元素进行调取。 所以，要自定义顺序表的结构： 顺序表的创建 顺序表的建立，也就是顺序表进行初始化，在预先申请内存空间的同时，给变量size和length赋初值： 顺序表查找元素 在数组中查找某个数据元素时，可以采取多种查找算法，例如二分查找、插值查找、斐...
【上机实验】01：顺序表扩容
https://blog.csdn.net/m0_74834215
04-17 3107
顺序表扩容 程序=算法+数据结构 数据结构=结构定义+结构操作 程序设计=算法+数据结构+编程范式 1.顺序表操作： 注意：顺序表与数组的不同点在于顺序表支持动态扩容操作 #include<stdio.h> #include<stdlib.h> #include<time.h> typedef struct{ int *data; int size, length; }SqList; //1.顺序表初始化 SqList *init(int n)
动态顺序表（可分配内存空间）
Lolita0917的专栏
06-27 4476
前几天写了一个静态顺序表，但是觉得一开始开辟很大一部分空间却不一定可以完全用得上，会造成很大的内存浪费，于是写了一个可以自动开辟内存空间的动态顺序表作为改进。 "DynamicSeqllist.h" #pragma once #define __SEQ_LIST__ #ifdef __SEQ_LIST__ #include #include #include #include ty
顺序表再次动态申请空间时，计算机自动完成copy
人间烟火气，最抚凡人心
06-14 1029
顺序表的插入算法中，若n个空间已满，可再申请增加m个空间，若申请失败，说明内存中已没有n+m个连续‾\underline{n+m个连续}n+m个连续​可分配的空间。 若申请成功，原位置的内容由计算机自动完成copy。 #include <iostream> using namespace std; int main() { int * a = (int *)malloc(sizeof(int) * 2); a[0] = 0; a[1] = 1; cout &lt
数据结构 顺序表（动态分配内存）
ElysiumAILab
04-20 1885
数据结构 顺序表（动态分配内存） 文章目录数据结构 顺序表（动态分配内存）前言一、顺序表二、代码部分1.头文件2.预定义3.定义存储结构4.顺序表初始化5.创建顺序表6.遍历顺序表7.销毁顺序表8.重置顺序表9判断顺序表是否为空10.按位查找顺序表11.按值查找顺序表12.顺序表某一位置插入元素13.顺序表删除某一位置元素14.主函数总结 前言 刚刚写了个静态分配内存的顺序表，再写个动态分配内存的顺序表对比 一、顺序表 顺序表有两种。一种为静态分配内存，另一种为动态分配内存。本文提供了一种动态分配内
顺序表（静态开辟内存）
John的博客
05-25 1302
# 简单实现顺序表 @ 本篇博客的顺序表类似于通讯录的静态实现：http://blog.csdn.net/bitboss/article/details/51374654 @ 本篇博客用到的冒泡排序方法：http://blog.csdn.net/bitboss/article/details/51192704 /* 顺序表功能：    EXIT
顺序表的动态内存实现
Atom丶的博客
05-31 817
线性表的顺序存储结构就是，把线性表中的所有元素按照其逻辑顺序依次存储在计算机存储器中指定存储位置开始的一块连续的存储空间中。因此，线性表的顺序存储结构是利用数组来实现的，数组的基本类型就是线性表中元素的类型。 实现一个顺序表首先要制定一个顺序表的长度和存放数据的地址，还必须有已经存放的数据数量和总数量，顺序表的实现可以是静态的也可以是动态的，不过静态比较浪费内存，所以采用动态内存分配来实现顺序表
数据结构-顺序表（动态分配存储空间）
热门推荐
快乐的小小程序猿
09-21 1万+
#include <stdio.h> #include <malloc.h> #include <stdlib.h> /** * 数组空间动态分配 */ #define InitSize 100 //动态分配存储空间时，不限制最大，只给定一个初始值 #define ListIncrement 10 //分配增量 typedef struct { int...
C++基础new和delete运算符，new和delete简介
kaikeba的博客
02-10 638
在C语言中，动态分配内存用 malloc() 函数，释放内存用 free() 函数。如下所示： int p = (int) malloc( sizeof(int) * 10 ); //分配10个int型的内存空间 free§; //释放内存 在C++中，这两个函数仍然可以使用，但是C++又新增了两个关键字，new 和 delete：new 用来动态分配内存，delete 用来释放内存。 C++new 用 new 和 delete 分配内存更加简单： int *p = new int; //分配1个in
动态顺序表（可扩容）的基本操作
fern_girl的博客
04-24 1498
头文件：#define _CRT_SECURE_NO_WARNINGS 1 #ifndef _STATICSEQLIST_H__ #define _STATICSEQLIST_H__#include<stddef.h> #include<assert.h> #include<string.h> #include<stdlib.h> #include<stdio.h>#define MAXSIZE 1
C语言动态顺序表实现详解及代码
在编程领域，动态顺序表是一种常见的数据结构，它在内存中分配一块可变大小的空间来存储数据，能够随着数据量的增长自动进行扩容。与静态顺序表不同，静态顺序表的大小在编译时就已经确定，而动态顺序表允许在运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值