顺序表的操作有以下：

1 顺序表的元素插入

给定一个索引和元素，这个位置往后的元素位置都要往后移动一次，元素插入的步骤有以下几步

（1）判断插入的位置是否合法，如果不合法则抛出异常

（2）如果是顺序表已满，则需要扩容顺序表，一般是将原有顺序表的容量进行倍增

（3）将插入位置之后的元素向后移动，为新元素腾出空间

（4）将新元素插入到指定位置

（5）更新顺序表的大小

2 顺序表的元素删除

将对应索引位置元素删除后，这个位置往后所有元素位置往前移动一次，元素删除有以下几步

（1）判断删除位置是否合法，如果不合法则抛出异常

（2）如果删除位置为最后一个元素，则顺序表的大小直接-1

（3）如果删除位置不是最后一个元素，则将删除位置之后的元素向前移动，覆盖要删除的元素

（4）更新顺序表的大小

3 顺序表的元素查找

找到元素位置，并且返回索引，查找步骤为

（1）遍历顺序表，对顺序表中每个元素与指定元素进行比较，如果找到则返回对应索引

（2）如果遍历完所有元素，都没有找到对应元素，则返回-1

4 顺序表的元素索引

直接即可获得

5 顺序表的元素修改

直接将给定位置改为对应的值

附顺序表代码见下：

#include<iostream>
using namespace std;
#define eleType int

struct SequentialList {
	eleType* elements;
	int size;
	int capacity;
};

void initializeList(SequentialList* list, int capacity) {
	list->elements = new eleType[capacity];
	list->size = 0;
	list->capacity = capacity;
}

void destoryList(SequentialList* list) {
	delete[] list->elements;
}

int size(SequentialList* list) {
	return list->size;
}

bool isEmpty(SequentialList* list) {
	return list->size == 0;
}

void insert(SequentialList* list, int index, eleType element) {
	if (index <0 || index > list->size) {
		throw std::invalid_argument("Invalid index");
	}

	if (list->size == list->capacity) {
		int newCapacity = list->capacity * 2;
		eleType *newelement = new eleType[newCapacity];
		for (int i = 0; i < newCapacity / 2; ++i) {
			newelement[i] = list->elements[i];
		}
		delete[] list->elements;
		list->elements = newelement;
		list->capacity = newCapacity;
	}
	if (list->size < list->capacity) {
		for (int i = list->size - 1; i > index; --i) {
			list->elements[i] = list->elements[i - 1];
		}
		list->elements[index] = element;
		list->size++;
	}

}
void deleteElement(SequentialList* list, int index) {
	if (index < 0 || index >= list->size) {
		throw std::invalid_argument("Invalid_index");
	}
	for (int i = index; i < list->size - 1; ++i) {
		list->elements[i] = list->elements[i + 1];
	}
	list->size--;
}

int findElement(SequentialList* list, eleType element) {
	for (int i = 0; i < list->size; ++i) {
		if (list->elements[i] == element) {
			return i;
		}
	}
	return -1;
}

eleType getElement(SequentialList* list, int index) {
	if (index < 0 || index >= list->size) {
		throw std::invalid_argument("Invalid_index");
	}
	return list->elements[index];
}

void updateElement(SequentialList* list, int index, eleType value) {
	if (index < 0 || index >= list->size) {
		throw std::invalid_argument("Invalid_index");
	}
	list->elements[index] = value;
}