顺序表的基本操作

一、定义：

        顺序表——用顺序存储的方式实现线性表顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

---

二、顺序表的两种实现方法

1.静态分配——使用静态“数组”来存放数据元素

①静态分配实现代码

//伪代码

#define MaxSize 10					//定义最大长度
typedef struct {
	ElemType data[MaxSize];			//ElemType指代数据类型
	int length;						//顺序表的当前长度
}SqList;			                //顺序表的类型定义（静态分配方式）

②具体例子：

#include<stdio.h>
#define MaxSize 10					        
typedef struct {
	int data[MaxSize];				        
	int length;						        
}SqList;
							        
void InitList(SqList& L)
{
	for (int i = 0; i < MaxSize; i++)		
		L. data[i] = 0;						
	L.length = 0;
}

int main()
{
	SqList L;
	InitList(L);
	return 0;
}

        需要注意的是，静态分配的顺序表这种情况，我们在初始化该顺序表时所用到的函数InitList里是用for循环对静态数组data中的每一个元素进行初始化。或者我们也可以省略这个for循环，也就是在InitList中仅对 length 进行初始化，并且“=0”这一步骤不能省略，因为我们无法预知在编译器给我们开辟的内存区域之前存放的是什么数据，也就是所谓的不确定是否存在“脏数据”。初始化这一步骤和后续所提到的动态分配方式中初始化的步骤有所不同。

        如果数组存满了后，因为这是一个静态数组，所以从一开始确定表长之后，就无法再进行修改；如果一开始就声明了一个非常大的空间，那么极有可能造成内存的浪费。所以引出更加灵活的动态分配方式来使顺序表的大小可变。

---

2.动态分配——指示动态分配数组的指针

①动态分配实现代码

#伪代码

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

②具体例子：

#include<stdio.h>
#include<stdlib.h>

#define InitSize 10  
typedef struct {
	int* data;      
	int MaxSize;      
	int length;      
}SqList;

void InitList(SqList& L)               
{
	L.data = (int*)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}

int main()
{
	SqList L;									
	InitList(L);								
	return 0;
}

        对比刚才的静态分配方式，我们发现动态分配方式在初始化函数InitList中是用malloc函数申请一片连续的存储空间，对length初始化、将MaxSize和InitSize保持一致即可。

        如果动态分配方式的指针数组也存满了，该如何进行顺序表大小的增加呢？

---

三、顺序表的基本操作

1.增加动态数组的长度IncreaseSize

        如果动态分配方式的指针数组也存满了，我们可以通过调用增加动态数组长度的基本操作函数IncreaseSize来进行顺序表大小的增加。

#define<stdio.h>
#define<stdlib.h>

#define InitSize 10  
typedef struct {
	int* data;      
	int MaxSize;     
	int length;      
}SeqList;

void InitList(SeqList& L)              
{
	L.data = (int*)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}

void IncreaseSize(SeqList& L, int len)          //增加动态数组的长度
{
	int* p = L.data;
	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);									//释放原来的内存空间
}

int main()
{
	SeqList L;									
	InitList(L);								
	IncreaseSize(L, 5);                         //将顺序表L的长度增加5
	return 0;
}

观察IncreaseSize函数：

①定义了一个指针p，把顺序表L.data的首地址赋值给p,即*data和*p指向同一个位置。

②调用malloc函数申请一整片的内存空间，注意这时已经多申请了len个长度的空间。

③用for循环将*p的数据复制到新区域*data。

④顺序表最大长度增加len。

⑤释放原来的内存空间p。

之后在主函数中调用IncreaseSize即可增加顺序表的长度。

---

2.顺序表的插入与删除ListInsert/ListDelete

①插入操作：ListInsert(&L,i,e):在表L中的第i个位置上插入指定元素e。

#伪代码

bool ListInsert(Sqlist& L, int i, int e)
{
	if (i<1 || i>L.length + 1)			    //判断i的范围是否有效
		return false;
	if (L.length > MaxSize)				    //当前存储空间已满，不能插入
		return false;
	for (int j = L.length; j >= i; j--)	    //将第i个元素及之后的元素后移
		L.data[j] = L.data[j - 1];    
	L.data[i - 1] = e;					    //在位置i处放入e
	L.length++;							    //长度+1
	return true;
}

代码分析：

（1）形参：&L，要对顺序表的值进行修改，所以要进行传址操作；i，表L中第i个位置；e，插入元素为e。

（2）bool类型最终返回true or false。

（3）首先对i的范围进行判断，i<1或i>length+1则返回false(i最大可以取到length，也就是在表尾插入；但不能大于length，也就是不能在前面有空位的情况下进行插入操作)。

（4）length长度不能大于maxsize，也就是当前的表长不能大于顺序表最大长度。

（5）使用for循环进行元素后移，由于我们是从后往前将后面的元素依次向后移动（先把最后一个元素后移，再倒数第二个后移......），所以j--进行移动；j初始值为length（从最后一个元素开始进行后移）；范围j>=i（将第i个元素后移后停止for循环）。

（6）在位置i处插入元素e，这里要注意，由于顺序表表头下标是从1开始，而我们所采用的数组下标访问方式是从0开始，所以顺序表第i个位置对应数组下标应该是i-1。

（7）插入一个元素e，表长+1。

（8）插入成功，return true。

插入操作时间复杂度为O(n)，其中问题规模n为表长L.length。

---

②删除操作：ListDelete(&L,i,&e):删除表L中第i个位置的元素，并用e返回删除元素的值。

#伪代码

bool ListDelete(Sqlist& L, int i, int& e)
{
	if (i<1 || i>L.length)
		return false;
	e = L.data[i - 1];
	for (int j = i; j < L.length; j++)
		L.data[j - 1] = L.data[j];
	L.length--;
	return true;
}

代码分析：

（1）形参：&L，要对顺序表的值进行修改，所以要进行传址操作；i，表L中第i个位置；&e，返回所删除元素的值，所以要进行传址操作。

（2）bool类型最终返回true or false。

（3）首先对i的范围进行判断，i<1或i>length+1则返回false(i最小可以取到1，也就是删除表头元素；最大可以取到length，也就是删除表尾元素)。

（4）将第i个位置的元素赋值给e，此处要注意下标的转换。

（5）使用for循环进行元素前移，由于我们是从前往后将前面的元素依次向前移动（先把第i个元素前移，再第i+1个前移......），所以j++进行移动；j初始值为i（从第i个元素开始进行前移）；范围j<length（将表尾元素前移后停止for循环）。

（6）删除一个元素e，表长-1。

（7）删除成功，return true。

删除操作时间复杂度为O(n)，其中问题规模n为表长L.length。

---

③按位查找GetElem(L,i):获取表L中第i个位置的元素的值。

第一种按位查找（静态分配按位查找）：

#伪代码

#define MaxSize 10								//定义最大长度
typedef struct
{
	int data[MaxSize];							//用静态的数组存放数据元素（静态分配）
	int length;									//顺序表的当前长度
}Sqlist;										//顺序表的类型定义（静态分配方式）
int GetElem(Sqlist L, int i)
{
	//这里还可以插入关于i的范围判断的代码
	return L.data[i - 1];
}

注意第i个位置对应下标为i-1。

第二种按位查找（动态分配按位查找）：

#伪代码

#define InitSize 10								//顺序表的初始长度
typedef struct {
	int* data;									//指示动态分配数组的指针
	int MaxSize;            					//顺序表的最大容量
	int length;									//顺序表的当前长度
}Sqlist;										//顺序表的类型定义（动态分配方式）
int GetElem(Sqlist L, int i)
{
	return L.data[i - 1];						
}

        注意在这里的GetElem函数中，虽然data这个变量是一个指针，但是同样可以用这种数组下标的方式访问相应元素。

按位查找操作的时间复杂度为O(1)。

---

④按值查找LocateElem(L,e):在表L中查找具有给定关键字值的元素。

#伪代码

int LocateElem(Sqlist L, int e)
{
	for (int i = 0; i < L.length; i++)
		if (L.data[i] == e)
			return i + 1;							//数组下标为i的元素值为e，返回其位序i+1
	return 0;										//退出循环，说明查找失败
}

注意在查找成功后，返回的i+1是位序。

按值查找操作的时间复杂度为O(n)。