【数据结构】顺序表

顺序表

顺序表的存储结构分为静态分配和动态分配两种分配的存储结构，其中静态分配的数组大小固定，而动态分配的数组大小可变。

1.一维数组的静态、动态分配

静态分配存储结构

//一维数组的静态分配 
#define MaxSize 50
typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;

其中MaxSize为数组的固定大小，后续将不可更改。

动态分配存储结构

//一维数组的动态分配 
#define InitSize 100
typedef struct {
	ElemType *data;
	int length, MaxSize;
}SqList;
//给L顺序表动态分配内存，使用malloc函数
SqList L;
L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);
//给顺序表追加空间，使用relloc函数
SqList LL;
LL.data = (ElemType)relloc(L.data, sizeof(ElemType)*InitSize*2);
LL.MaxSize = L.Max

其中使用data指针指向使用malloc函数分配的顺序表的起始元素，从而达到动态调节顺序表大小的效果。

2.顺序表的插入操作

bool ListInsert(SqList &L, int i, ElemType e) {
	/*将元素e插入表中*/
	//1.判断插入位置是否合法 
	if(i<1 || i>L.length+1)
		return false
	//2.判断数组是否已满
	if(L.length == MaxSize)
		return false;
	//3.插入（移动元素）
	for (int j=L.length-1; j>=i; j--){
		L.data[j+1] = L.data[j];
	} 
	//4.插入（插入元素）
	L.data[i-1] = e; 
	L.length++;
	return true;
}

当插入元素时：
1.最少移动次数是0次；
2.最多移动次数是n次；
3.平均移动次数是${\sum }_{i=1}^n{p}_i(n-i+1)=n/2$
其中$p_i$为插入i处的概率，为1/(n+1)

3.顺序表的删除操作

bool ListDelete(SqList &L, int i, ElemType &e){
	/*删除指定位置的元素，并通过e返回*/
	//1.判断删除位置是否有效 
	if(i > L.length)
		return false;
	//2.删除元素（赋值e） 
	e = L.data[i-1];
	//3.删除元素（移动） 
	for (int j=i-1; j<L.length; j++){
		L.data[j] = L.data[j+1];
	} 
	L.length--;
	return true;
}

当删除元素时：
1.最少移动次数是0次；
2.最多移动次数是n次；
3.平均移动次数是${\sum }_{i=1}^n{p}_i(n-i)=(n-1)/2$
其中$p_i$为删除i处元素的概率，为1/n

4.顺序表的查找操作

int locateElem(SqList &L, ElemType e) {
	/*查找元素e*/
	//1.如果查找成功，返回元素位置 ;
	for (int i=0; i<L.length; i++){
		if (L.data[i] == e)
			return i+1; 
	} 
	//2.如果查找失败，返回0;
	return 0; 
}

当查找元素时：
1.最少比对次数是0次；
2.最多比对次数是n次；
3.平均比对次数是${\sum }_{i=1}^n{p}_i\ast i=(n+1)/2$
其中$p_i$为与i处元素比对的概率，为1/n