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

一、顺序表的定义

1. 顺序表的定义

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

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 如果“数组”存满了怎么办?
• 顺序表的表长刚开始确定后就无法更改(存储空间是静态的）
• 思考：如果刚开始就声明一个很大的内存空间？会存在什么问题？ ---------- 浪费！

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

1
2
3
4
5
6

3. 顺序表的实现---------动态分配

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

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

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关键字
1
2
3
4
5
6
7
8
9
10
11

• malloc函数申请的是一整片连续的存储空间，malloc函数返回一个指针，需要强制转换型为你定义的数据元素类型指针。
• malloc函数的参数，指明要分配多大的连续内存空间。
  

#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更能理解背后的过程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

4.顺序表的实现

顺序表：

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

：链式存储

• 除了存储数据元素之外，还需要耗费一定存储空间来存放指针。
  
  顺序表思维导图：