线性表——顺序表的增删改查

一、顺序表的特点

逻辑上相邻的两个元素在物理位置上也相邻。

二、顺序表的优缺点

优点

1.可随机存取，根据表头元素地址和元素序号表示表中任意一个元素。简单来说可以用公式到达任意元素。
2.存储密度高，每个结点只存储数据元素。

缺点

1.插入和删除操作需要移动大量元素。
2.线性表变化较大时，难以确定存储空间的容量。
3.村年初分配需要一整段连续的存储空间，不够灵活。

三、代码实现

结构体

#define MaxSize 50
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];
	int length; // 当前顺序表有多少个元素
}SqlList;

1.增（插入）

// 插入元素到顺序表
bool ListInsert(SqlList& L, int i, ElemType e) {
	// 判断插入的位置是否合法
	if (i<1 || i>L.length + 1) {
		return false;
	}
	if (L.length >= MaxSize) {
		return false; // 超出空间了
	}
	// 整体→移
	// 插入元素往顺序表中，分为两步。
	// 第一步，将这个元素想要插入的位置及以后往后挪一个位置，即挪完后这个元素位置存储的是上一个元素。
	// 第二步，将这个元素插入对应的位置，线性表长度加1。
	for (int j = L.length; j >= i; j--) {
		L.data[j] = L.data[j - 1];
	}
	L.data[i-1] = e; // 将插入的元素放在对应位置
	L.length++; // 顺序表长度加一
	return true;
}

2.删（删除）

// 从顺序表中删除元素
bool ListDel(SqlList& L, int i, ElemType &e) {
	// 判断删除位置是否合法
	if (i<1 || i>L.length) {
		return false;
	}
	// 如果顺序表中没有元素，无需删除
	if (L.length == 0) {
		return false;
	}
	// 整体←移
	e = L.data[i - 1]; // 将删除的元素赋值给e
	for (int j = i; j < L.length; j++) {
		L.data[j - 1] = L.data[j];
	}
	L.length--; // 顺序表长度减一
	return true;
}

3.改（修改）

// 从顺序表中修改元素
bool ListMod(SqlList& L, int i, ElemType e) {
	// 判断修改位置是否合法
	if (i<1 || i>L.length) {
		return false;
	}
	for (int j = 0; j < L.length; j++) {
		if (j == (i-1)) {
			L.data[j] = e;
			return true;
		}
	}
}

4.查（查找）

bool ListLocate(SqlList &L,int i,ElemType &e){
	// 判断查找位置是否合法
	if (i<1 || i>L.length) {
		return false;
	}
	for (int j = 0; j < L.length; j++) {
		if (L.data[j] == i) {
			e = j + 1; // 加1表示在顺序表的位置
			return true;
		}
	}
	return false;
}

完整代码

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

#define MaxSize 50
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];
	int length; // 当前顺序表有多少个元素
}SqlList;

// 插入元素到顺序表
bool ListInsert(SqlList& L, int i, ElemType e) {
	// 判断插入的位置是否合法
	if (i<1 || i>L.length + 1) {
		return false;
	}
	if (L.length >= MaxSize) {
		return false; // 超出空间了
	}
	// 整体→移
	// 插入元素往顺序表中，分为两步。
	// 第一步，将这个元素想要插入的位置及以后往后挪一个位置，即挪完后这个元素位置存储的是上一个元素。
	// 第二步，将这个元素插入对应的位置，线性表长度加1。
	for (int j = L.length; j >= i; j--) {
		L.data[j] = L.data[j - 1];
	}
	L.data[i-1] = e; // 将插入的元素放在对应位置
	L.length++; // 顺序表长度加一
	return true;
}

// 从顺序表中删除元素
bool ListDel(SqlList& L, int i, ElemType &e) {
	// 判断删除位置是否合法
	if (i<1 || i>L.length) {
		return false;
	}
	// 如果顺序表中没有元素，无需删除
	if (L.length == 0) {
		return false;
	}
	// 整体←移
	e = L.data[i - 1]; // 将删除的元素赋值给e
	for (int j = i; j < L.length; j++) {
		L.data[j - 1] = L.data[j];
	}
	L.length--; // 顺序表长度减一
	return true;
}

// 从顺序表中修改元素
bool ListMod(SqlList& L, int i, ElemType e) {
	// 判断修改位置是否合法
	if (i<1 || i>L.length) {
		return false;
	}
	for (int j = 0; j < L.length; j++) {
		if (j == (i-1)) {
			L.data[j] = e;
			return true;
		}
	}
}

// 从顺序表中查找元素
bool ListLocate(SqlList &L,int i,ElemType &e){
	// 判断查找位置是否合法
	if (i<1 || i>L.length) {
		return false;
	}
	for (int j = 0; j < L.length; j++) {
		if (L.data[j] == i) {
			e = j + 1; // 加1表示在顺序表的位置
			return true;
		}
	}
	return false;
}

// 打印顺序表
void PrintList(SqlList& L) {
	for (int i = 0; i < L.length; i++) {
		printf("%4d", L.data[i]);
	}
	printf("\n");
}

int main()
{
	SqlList L; // 顺序表的名称
	bool ret; // 查看返回值，布尔值
	ElemType del; // 用来存要删除的元素
	ElemType loc; // 用来存要查找的元素
	// 初始化顺序表
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.data[3] = 4;
	L.data[4] = 5; // 总共5个元素
	L.length = 5;
	// 插入
	ret = ListInsert(L, 2, 60); // 调用函数，往第二个位置插入60这个元素
	if (ret) {
		printf("插入成功\n");
		PrintList(L); // 调用函数，打印顺序表
	}
	else {
		printf("插入失败\n");
	}
	// 删除
	ret = ListDel(L, 4, del);
	if (ret) {
		printf("删除成功\n");
		printf("删除元素为：%d\n", del);
		PrintList(L); // 调用函数，打印顺序表
	}
	else {
		printf("删除失败\n");
	}
	// 修改
	ret = ListMod(L, 1, 70); // 调用函数，将第1个位置的元素修改成70
	if (ret) {
		printf("修改成功\n");
		PrintList(L); // 调用函数，打印顺序表
	}
	else {
		printf("修改失败\n");
	}
	// 查找
	ret = ListLocate(L,2, loc);
	if (ret) {
		printf("查找成功\n");
		printf("该元素在：%d位置\n", loc);
		PrintList(L); // 调用函数，打印顺序表
	}
	else {
		printf("查找失败\n");
	}
	return 0;
}

注意

顺序表的下标从1开始！！！