顺序表：顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。即线性表采用顺序存储的方式存储就称之为顺序表。
下面直接上代码：

 //SeqList.h

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

typedef int SLdatatype;

typedef struct SeqList
{
	SLdatatype *a;//存储数据空间的指针
	int capacity;//容量空间大小
	int size;//有效数据个数
}SeqList;

void SeqListInit(SeqList *psl);//初始化
void SeqListDestroy(SeqList *psl);//删除
void SeqListPrint(SeqList *psl);//输出
void SeqListPushBack(SeqList *psl, SLdatatype x);//尾插
void SeqListPushFront(SeqList *psl, SLdatatype x);//头插
void SeqListPopBack(SeqList *psl);//尾删
void SeqListPopFront(SeqList *psl);//头删
void SeqListInsert(SeqList *psl, int pos, SLdatatype x);//按位置插入元素
void SeListErase(SeqList *psl, int pos);//按位置删除元素


 //SeqList.c

#include"SeqList.h"

void SeqListInit(SeqList *psl)
{
	psl->a = (SLdatatype*)malloc(sizeof(SLdatatype)*4);
	if (psl->a == 0){
		printf("malloc fail\n");
		exit(-1);
	}
	memset(psl->a, 0, sizeof(SLdatatype) * 4);
	psl->size = 0;
	psl->capacity = 4;
}

void SeqListDestroy(SeqList *psl)
{
	free(psl->a);
	psl->a = NULL;
	psl->capacity = psl->size = 0;
}

void SeqListPrint(SeqList *psl)
{
	for (int i = 0; i < psl->size; i++){
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

void CheckCapacity(SeqList* psl)
{
	if (psl->size == psl->capacity){
		SLdatatype *b = (SLdatatype*)realloc(psl->a, sizeof(SLdatatype)*psl->capacity * 2);
		if(b == NULL){
			printf("malloc fail\n");
			exit(-1);
		}
		psl->a = b;
		psl->capacity = psl->capacity * 2;
	}
}

void SeqListPushBack(SeqList *psl, SLdatatype x)
{
	    assert(psl);
		CheckCapacity(psl);
        psl->a[psl->size] = x;
	    psl->size++;

}

void SeqListPushFront(SeqList *psl, SLdatatype x)
{
	assert(psl);
	CheckCapacity(psl);
	for (int i = psl->size; i >0; i--){
		psl->a[i] = psl->a[i - 1];
	}
	psl->a[0] = x;
	psl->size++;
}

void SeqListPopBack(SeqList *psl)
{
	assert(psl);
	assert(psl->size > 0);
	psl->size--;
}

void SeqListPopFront(SeqList *psl)
{
	assert(psl);
	assert(psl->size > 0);
	for (int i = 0; i < psl->size; i++){
		psl->a[i] = psl->a[i + 1];
	}
	psl->size--;
}

void SeqListInsert(SeqList *psl, int pos, SLdatatype x)
{
	assert(psl);
	assert(pos >= 0 && pos <= psl->size);
	CheckCapacity(psl);
	int i;
	for (i = psl->size; i>=pos; i--){
		psl->a[i] = psl->a[i - 1];
	}
	psl->a[pos] = x;
	psl->size++;
}

void SeListErase(SeqList *psl, int pos)
{
	assert(psl);
	assert(pos >= 0 && pos <= psl->size);
	for (int i = pos+1; i < psl->size; i++){
		psl->a[i - 1] = psl->a[i];
	}
	psl->size--;
}


 //test.c

#include"SeqList.h"

int main()
{
	SeqList s1;
	SeqListInit(&s1);
	SeqListPushBack(&s1, 1);
	SeqListPushBack(&s1, 2);
	SeqListPushBack(&s1, 3);
	SeqListPushBack(&s1, 4);
	SeqListPushBack(&s1, 5);
	SeqListPrint(&s1);
	SeqListPushFront(&s1, 0);
	SeqListPrint(&s1);
	SeqListPopBack(&s1);
	SeqListPrint(&s1);
	SeqListPopFront(&s1);
	SeqListPrint(&s1);
	SeqListInsert(&s1,2,10);
	SeqListPrint(&s1);
	SeListErase(&s1,2);
	SeqListPrint(&s1);
}

一个数据结构的基本操作是指其最核心，最基本的操作。其他较复杂的操作可t通过调用其基本操作来实现。首先我们来了解一下线性表的基本操作：
1.InitList(&L):初始化表。构造一个空的线性表。
2.Length(L):求表长，返回线性表的长度。
3.LocateElement(L,e)：按值查找。查找e在L中的位置。
4.GetElement(L,i):按位置查找。返回下标为i的元素。
5.ListInsert(&L,i,e):插入操作。在表中I位置插入元素e。
6.ListDElete(&L,i,&e):删除操作。删除i位置的元素，并用e返回删除的值。
7.PringList(L):输出操作。
8.Empty(L):判空操作。判断线性表是否为空。
9.DestroyLIst(&L):销毁操作。销毁线性表，并释放线性表L的所有元素值。
注：
1.具体的实现取决于采用哪种存储结构，存出结构也不同，算法的实现也不同。
2.&表示C++中的引用。若传入的变量是指针型变量，且在函数体内要对传入的指针进行改变，则会用到指针变量的引用型。
3.后边我会用C++来实现一下关于顺序表的几种基本操作，
欢迎关注，留言，讨论，指正，共同学习呀。

	

点击上面“蓝字”关注我们  
在上一篇文章中，我们学习了 时空转换 的思想，而它的核心就是选择合适的数据结构，将时间复杂度向空间复杂度转换。那么该 如何选择合适的数据结构 呢？
要想灵活使用数据结构，你需要先弄清楚数据在代码中被处理、加工的最小单位动作，也就是数据结构的 基本操作，有了这些动作之后，你就可以基于此去选择更合适的数据结构了。
1. 举个栗子：代码对数据处理
例1：查找出一个数组中，出现次数最多的那个元素的数值。例如，输入数组 a = [1,6,3,5,5,5,6 ] 中，查找出现次数最多的数值。
这个例子我们在上一篇中已经分析过。使用 字典 的数据结构能使时间复杂度降低到O(n)，那究竟是什么让我们选择字典呢？下面仔细来聊一聊。
我们先看一下这个任务需要对数据进行哪些操作。我们在解这个题时，核心思路应该是：
第一步，根据原始数组计算每个元素出现的次数；
第二步，根据第一步的结果，找到出现次数最多的元素。
(1)对于上面的第一步，可以提取出的基本数据操作有：
查找：看能否在数据结构中查找到这个元素，也就是判断元素是否出现过。
新增：针对没有出现过的情况，新增这个元素。
改动：针对出现过的情况，需要对这个元素出现的次数加 1。
(2)对于上面的第二步，可以提取出的基本数据操作有：
查找：访问数据结构中的每个元素，找到次数最多的元素。
由此可见，本任务会 重复使用到查找。而能在 O(1) 的时间复杂度内完成查找动作的数据结构，只有字典类型。因此选择字典结构可能会比其他数据结构效率更高，事实也是如此。
注：此题解法可参考：【算法与数据结构 02】选择合适的数据结构——将昂贵的“时间”转换为廉价的“空间”
2. 数据处理的基本操作
设计合理的数据结构，要从问题本身出发，我们可以采用这样的思考顺序：
(1) 分析这段代码到底对数据先后进行了哪些操作。
(2) 根据分析出来的数据操作，找到合理的数据结构。
这样我们就把数据处理的基本操作梳理了出来。今后，即使你遇到更复杂的问题，无非就是这些 基本操作的叠加和组合。只要按照上述的逻辑进行思考，就可以 轻松设计出合理的数据结构！
数据处理的操作就是找到需要处理的数据，计算结果，再把结果保存下来。这个过程总结为以下操作：
(1) 找到要处理的数据。这就是按照某些条件进行查找。
(2) 把结果存到一个新的内存空间中。这就是在现有数据上进行新增。
(3) 把结果存到一个已使用的内存空间中。这需要先删除内存空间中的已有数据，再新增新的数据。
3. 方法论
经过对问题的拆解，你会发现即便是很复杂的代码，它对数据的处理也只有这 3 个基本操作，增、删、查。只要围绕这 3 个数据处理的操作进行分析，就能选择出合适的方案。总结下来，我们在思考代码优化时，可以从以下三个问题入手：
(1) 这段代码对数据进行了哪些操作？
(2) 这些操作中，哪个操作最影响效率，对时间复杂度的损耗最大？
(3) 哪种数据结构最能帮助你提高数据操作的使用效率？
对于前面两个问题，围绕数据处理的基本操作，这可以通过 刷题 加深我们的理解。对于第3个问题，就需要我们去掌握相应的数据结构 基础知识，这个我在后面也会逐渐整理出来。
创作不易，点个在看再走吧 

顺序表基本操作的代码实现
初始化
静态分配方式
#include <stdio.h>
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 

/**
* 初始化函数 
*
* @param L 顺序表指针 
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}


int main(){
	SqList L;
	InitList(L);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	printf("length=%d", L.length);
	
	return 0;
}

输出
0 0 0 0 0 0 0 0 0 0 length=0
--------------------------------
Process exited with return value 0
Press any key to continue . . .

动态分配方式
#include <stdio.h>
#include <stdlib.h>
#define InitSize 10 //默认最大长度

typedef struct{
	int *data;	//指示动态分配数组的指针 
	int MaxSize; //最大容量 
	int length; //顺序表的当前长度 
}SeqList; 

/**
* 初始化 
*
* @param L 顺序表指针 
*/
void InitList(SeqList &L){
	//用 malloc 函数申请一片连续的存储空间 
	L.data=(int *)malloc(InitSize*sizeof(int));
	L.length=0;
	L.MaxSize=InitSize;
	
	for(int i=0; i<InitSize; i++)
		L.data[i]=0; //初始化为0 
}

/**
* 动态增加数组长度 
*
* @param L 顺序表指针 
* @param len 增加的长度
*/
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; //扩大长度 
	free(p); //释放原来的内存空间 
} 

int main(){
	SeqList L;
	InitList(L);
	
	for(int i=0; i<L.MaxSize; i++)
		printf("%d ", L.data[i]);
	printf("\n原来size=%d", L.MaxSize);
	
	IncreaseSize(L, 5);
	printf("\n当前size=%d\n", L.MaxSize);
	
	return 0;
}


输出
0 0 0 0 0 0 0 0 0 0
原来size=10
当前size=15

--------------------------------
Process exited with return value 0
Press any key to continue . . .

插入
/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

操作小记
代码
#include <stdio.h>
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	return 0;
}


效果：
2 3 0 0 0 0 0 0 0 0
--------------------------------
Process exited with return value 0
Press any key to continue . . .

删除
/**
* 删除
*
* @param L 顺序表指针
* @param i 输出的位置，即位序i 
* @param e 删除的值 
* @return 是否插入成功 
*/
bool ListDelete(SqList &L, int i, int &e){
	if(i<1 || i>L.length)
		return false;
		
	e=L.data[i-1]; //将被删除的元素赋值给e 
	
	for(int j=i; j<L.length; j++) //将第i个位置后的元素前移 
		L.data[j-1]=L.data[j];
	L.length--;  //线性表长度减1 
	
	return true;
}

操作小记
代码
#include <stdio.h>
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

/**
* 删除
*
* @param L 顺序表指针
* @param i 输出的位置，即位序i 
* @param e 删除的值 
* @return 是否插入成功 
*/
bool ListDelete(SqList &L, int i, int &e){
	if(i<1 || i>L.length)
		return false;
		
	e=L.data[i-1]; //将被删除的元素赋值给e 
	
	for(int j=i; j<L.length; j++) //将第i个位置后的元素前移 
		L.data[j-1]=L.data[j];
	L.length--;  //线性表长度减1 
	
	return true;
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	int e=-1;
	ListDelete(L, 1, e);
	printf("\nres=%d\n", e);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);
	
	return 0;
}


效果
2 3 0 0 0 0 0 0 0 0
res=2
3 3 0 0 0 0 0 0 0 0
--------------------------------
Process exited with return value 0
Press any key to continue . . .

查找
按位查找
/**
* 按位查找
*
* @param L 顺序表指针
* @param i 位序i  
* @return 该位置的值
*/
int GetElem(SqList L, int i){
	return L.data[i-1];
}

操作小记
代码
#include <stdio.h>
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

/**
* 按位查找
*
* @param L 顺序表指针
* @param i 位序i 
* @return 该位置的值
*/
int GetElem(SqList L, int i){
	return L.data[i-1];
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);

	printf("\n第一个值为：%d", GetElem(L, 1)); 
	
	return 0;
}


效果
2 3 0 0 0 0 0 0 0 0
第一个值为：2
--------------------------------
Process exited with return value 0
Press any key to continue . . .

按值查找
/**
* 按值查找
*
* @param L 顺序表指针
* @param e 获取的值 
* @return 该值的位序 
*/
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; //退出循环，说明查找失败 
}

操作小记
代码
#include <stdio.h>
#define MaxSize 10 	//定义最大长度

typedef struct{
	int data[MaxSize];	//存放数据元素 
	int length;	//当前长度 
}SqList;	//顺序表的类型定义 



/**
* 初始化 
*
* @param L 顺序表指针
*/
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++)
		L.data[i]=0; //初始化为0 
	L.length=0; //初始长度为0 
}

/**
* 插入
*
* @param L 顺序表指针
* @param i 插入的位置，即位序i 
* @param e 插入值 
* @return 是否插入成功 
*/
bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1)
		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;
}

/**
* 按值查找
*
* @param L 顺序表指针
* @param e 获取的值 
* @return 该值的位序 
*/
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; //退出循环，说明查找失败 
}

int main(){
	SqList L;
	InitList(L);
	
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 2);
	
	for(int i=0; i<MaxSize; i++)
		printf("%d ", L.data[i]);

	printf("\n元素值为3的位序：%d", LocateElem(L, 3)); 
	
	return 0;
}


效果
2 3 0 0 0 0 0 0 0 0
元素值为3的位序：2
--------------------------------
Process exited with return value 0
Press any key to continue . . .