1.11 线性表的顺序存储结构（C语言）

线性表顺序实现

• 是用一组地址连续的存储单元依次存储线性表的数据元素

#include <stdio.h>
#include <stdlib.h>
#define N 6
typedef struct LNode *List;
struct LNode {
	int Data[N];
	int Last;//线性表最后一位
	int length; //当前长度
	int listsize;//当前分配的存储容量
};

/* 初始化 */
List MakeEmpty(List PtrL) {

	PtrL = (List)malloc(sizeof(struct LNode));
	PtrL->Last = -1;
	PtrL->length = 0;
	PtrL->listsize = sizeof(struct LNode) / sizeof(List);
	return PtrL;

}

/* 查找 */
int Find(int X, List PtrL) {
	int i = 0;
	while (i <= sizeof(PtrL->Data) / sizeof(int) - 1 && PtrL->Data[i] != X)
		i++;
	if (i > sizeof(PtrL->Data) / sizeof(int) - 1)  return -1;/* 如果没找到，返回错误信息 */
	else return i;/* 找到后返回的是存储位置 */

}
int Find2(int X, List PtrL) {
	int i = 0;
	while (i <= PtrL->length + 1 && PtrL->Data[i] != X)
		i++;
	if (i > PtrL->length + 1)  return -1;
	else return i;

}

/* 插入 */
bool Insert(List L, int X, int P)
{ /* 在L的指定位置P前插入一个新元素X */
	int i;

	/*
	if (L->Last >= N) {
		// 表空间已满，不能插入 
		printf("表满，动态扩容\n");
		L = (List)malloc(sizeof(int)*(L->listsize + 1));//动态扩容
		//L = (List)realloc(L->Data, (L->listsize + 1) * sizeof(int));
		//return false;
	}
*/
	if (P<0 || P> sizeof(L->Data) / sizeof(int) + 1) { /* 检查插入位置的合法性 */
		printf("位置不合法\n");
		return false;
	}

	for (i = sizeof(L->Data) / sizeof(int); i >= P; i--) {
		L->Data[i + 1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */
	}

	//L->Data[P + 1] = L->Data[P];
	L->Data[P] = X;  /* 新元素插入 */
	//L->listsize += 1;//更新顺序表大小
	//L->Last++;       /* Last仍指向最后元素 */
	//++L->length;
	//L->listsize++;
	return true;
}

/* 删除 */
bool Delete(List L, int P)
{ /* 从L中删除指定位置P的元素 */
	int i;

	if (P<0 || P>sizeof(L->Data) / sizeof(int)) { /* 检查空表及删除位置的合法性 */
		printf("位置%d不存在元素\n", P);
		return false;
	}
	for (i = P + 1; i <= sizeof(L->Data) / sizeof(int); i++)
		L->Data[i - 1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */
	L->Last = -1; /* Last仍指向最后元素 */
	//L->length--;
	//L->listsize--;
	return true;
}

void show(List PtrL) {
	printf("\n");
	printf("PtrL线性表最后一位为%d\n", PtrL->Last);
	printf("PtrL线性表长度为%d位\n", PtrL->length + 1);
	printf("PtrL线性表存储容量为%d位\n", PtrL->listsize);

}
void putlist(List PtrL,int m) {
	PtrL->length = m;
	printf("PtrL线性表元素为\n");
	for (int i = 0; i < PtrL->length + 1; i++) {
		printf("%d\t", PtrL->Data[i]);
	}
}

int main() {
	struct LNode L; //结构体变量
	List PtrL;//结构体指针 
	PtrL = NULL;
	int i = 0, m = 0;

	PtrL = MakeEmpty(PtrL);
	printf("PtrL->Data共%d位(包含\\0位)\n", sizeof(PtrL->Data) / sizeof(int) + 1);

	for (i = 0; i < N; i++) {
		scanf("%d", &(PtrL->Data[i]));
		if (i >= PtrL->length) m = i;
	}
	putlist(PtrL, m);
	show(PtrL);


	printf("PtrL->Data共%d位\n", sizeof(PtrL->Data) / sizeof(int));
	printf("2在PtrL第%d位\n", Find2(2, PtrL));

	Insert(PtrL, 1000, 0);//在第0位上插入1000
	printf("在第0位上插入1000\n");
	//PtrL->length = m;
	PtrL->length++;
	PtrL->listsize++;
	putlist(PtrL, m+1);
	show(PtrL);

	Insert(PtrL, 2000, 0);//在第0位上插入2000
	printf("在第0位上插入2000\n");
	//PtrL->length = m;
	PtrL->length++;
	PtrL->listsize++;
	putlist(PtrL, m +1);
	show(PtrL);


	Delete(PtrL, 2);//删除第2位
	printf("删除第2位\n");
	//PtrL->length = m;
	PtrL->length--;
	PtrL->listsize--;
	putlist(PtrL, m +1);
	show(PtrL);

	return 0;

}

运行

PtrL->Data共7位(包含\0位)
1 2 3 4 5 6
PtrL线性表元素为
1       2       3       4       5       6
PtrL线性表最后一位为-1
PtrL线性表长度为6位
PtrL线性表存储容量为9位
PtrL->Data共6位
2在PtrL第1位
在第0位上插入1000
PtrL线性表元素为
1000    1       2       3       4       5       6
PtrL线性表最后一位为6
PtrL线性表长度为7位
PtrL线性表存储容量为10位
在第0位上插入2000
PtrL线性表元素为
2000    1000    1       2       3       4       5
PtrL线性表最后一位为5
PtrL线性表长度为7位
PtrL线性表存储容量为11位
删除第2位
PtrL线性表元素为
2000    1000    2       3       4       5       -1
PtrL线性表最后一位为-1
PtrL线性表长度为7位
PtrL线性表存储容量为10位

博主如今掌握的C语言数组扩容是需要重新创建一个比原来空间大的数组并分配空间，然后把原来的数组内存空间释放掉，现如今数组满了之后插入，只能把最后一个元素顶替掉