顺序表的定义与实现(数据结构与算法)

一、顺序表的定义

1. 顺序表的定义

#define MaxSize 10                        //定义最大长度
typedef struct{                           
	ElemType data[MaxSize];              //用静态的“数组”存放数据元素
	int length;                          //顺序表的当前长度
}SqList;                                 //顺序表的类型定义(静态分配方式)
2.顺序表的实现---------静态分配

当我们声明一个顺序表的时候,把length值置为0是很有必要的: L.length = 0;

#include
#define MaxSize 10                       //定义最大长度
typedef struct{                           
	ElemType data[MaxSize];              //用静态的“数组”存放数据元素
	int length;                          //顺序表的当前长度
}SqList;                                 //顺序表的类型定义(静态分配方式)  

//基本操作 ------初始化一个顺序表
void InitList(SqList &L)
{
	for (int i = 0; i < MaxSize; i++)
		L.data[i] = 0;                  //将所有数据元素设置为默认初始值
	L.length = 0;                       //顺序表初始长度为0
}
int main()
{
	SqList L;                        //声明一个顺序表
	InitList(L);                     //初始化顺序表
	// ............后续操作
	return 0;
}
  • 如果“数组”存满了怎么办?
  • 顺序表的表长刚开始确定后就无法更改(存储空间是静态的)
  • 思考:如果刚开始就声明一个很大的内存空间?会存在什么问题? ---------- 浪费!
#define MaxSize 10                   //定义最大长度
typedef struct{
	ElemType data[MaxSize];         //用静态的“数组”存放数据元素
	int length;                     //顺序表的当前长度
}SqList;                            //顺序表的类型定义

3. 顺序表的实现---------动态分配
顺序表是一种线性表的存储结构,可以在连续的内存空间中存储元素。动态分配顺序表是指在需要时,根据实际情况动态增加或释放存储空间。

顺序表的定义与实现(数据结构与算法)_第1张图片

以下是实现动态分配顺序表的基本步骤:

1.定义结构体或类:首先,需要定义一个结构体或类来表示顺序表,可以包含如下成员:

  • 数据区域的指针,用于存储元素的数组。
  • 当前顺序表的大小(元素个数)。
  • 当前分配的存储空间大小。
  • 其他辅助变量或信息。

2.创建动态顺序表:在内存中分配一定大小的空间作为动态顺序表的初始存储空间,并初始化顺序表的各个成员。可以使用动态内存分配函数(如malloc)来分配空间。

3.插入元素:当需要插入新元素时,按照顺序表的逻辑顺序找到插入位置。如果当前存储空间不足以容纳新元素,则需要进行动态扩容,重新分配更大的存储空间,并将原有的元素复制到新的空间中。

4.删除元素:当需要删除元素时,将待删除元素后面的元素向前移动,填补删除位置,并更新顺序表的大小。如果删除元素后,剩余存储空间占比过低,可以考虑进行动态缩容,释放多余的存储空间。

5.销毁顺序表:当顺序表不再使用时,需要释放占用的内存空间,即使用动态内存释放函数(如free)释放动态顺序表的存储空间。

#define InitSize 10            //顺序表的初始长度
typedef struct{
	ElemType *data;             //指示动态分配数组的指针
	int MaxSize;                //顺序表的最大容量
	int length;                 //顺序表的当前长度
}SeqList;                       //顺序表的类型定义 (动态分配方式)

//Key: 动态申请和释放内存空间   
//C---- malloc、free函数
		L.data = (Elem Type*) malloc(sizeof(ElemType), *InitSize);
//C++---new、delete关键字
  • malloc函数申请的是一整片连续的存储空间,malloc函数返回一个指针,需要强制转换型为你定义的数据元素类型指针。
  • malloc函数的参数,指明要分配多大的连续内存空间。
    顺序表的定义与实现(数据结构与算法)_第2张图片
#include            //malloc、free函数的头文件
#define InitSize 10          //默认的最大长度
typedef struct{
	int *data;               //指示动态分配数组的指针		
	int MaxSize;             //顺序表的最大容量
	int length;              //顺序表的当前长度
}SeqList;

void InitList(SeqList &L){
	//用malloc函数申请一片连续的存储空间,如下图所示
	//调用malloc函数,申请一整片连续存储空间,其大小能存的下10个int类型数据。
	//malloc会返回一个指针类型,将其转换成和int *data;同类型的指针类型(int *),然后将返回值赋值给data
	L.data = (int *)malloc(InitSize*sizeof(int));
	//malloc返回的是开辟的一整片存储空间的起始地址->data[0]
	L.length = 0;
	L.MaxSize = InitSize; //将顺序表最大容量设置为初始值
}

//增加动态数组的长度
void IncreaseSize(SeqList &L, int len){
	int *p = L.data;      //将顺序表data指针的值赋给指针p,即p指针和data指向同一个位置
	//调用malloc函数,申请的另一块内存空间能够存得下当前所有数据元素,再多存5个新的数据元素,
	//再乘以每个数据元素的大小
	L.data = (int *)malloc((L.MaxSize + len)*sizeof(int));
	for(int i = 0; i < L.length; i++)
	{
		L.data[i] = p[i];     //将数据复制到新区域(时间开销大)
	}
	L.MaxSize = L.MaxSize + len;  //顺序表最大长度增加len
	//free会将p指针所指向的一整片(原空间)释放掉,归还给系统,这样就实现了内存的扩展。  
	free(p);                //释放原来的内存空间
	//由于*p是局部变量,在该函数执行完后,*p所在内存空间会被系统自动释放
}

int main()
{
	SeqList L;           //声明一个顺序表,计算机会开辟一小块存储空间用来存储SeqList顺序表
	InitList(L);         //初始化顺序表
	//......往顺序表中插入几个元素.......
	IncreaseSize(L, 5);
	return 0;
}

//realloc函数也可以实现,但建议初学者使用malloc和free更能理解背后的过程。

4.顺序表的实现

顺序表:

  • 随机访问,即可以在O(1)常数级时间内找到第i个元素。 data[i-1]
  • 存储密度高,每个节点只存储数据元素。
  • 扩展容量不方便,(即便采用动态分配的方式实现,扩展长度的时间复杂度也比较高)。
  • 插入删除不方便,需要移动大量元素

:链式存储

  • 除了存储数据元素之外,还需要耗费一定存储空间来存放指针。
    顺序表的定义与实现(数据结构与算法)_第3张图片
    顺序表思维导图:
    顺序表的定义与实现(数据结构与算法)_第4张图片

你可能感兴趣的:(C/C++,数据结构与算法,数据结构,顺序表,动态分配,C)