顺序表的基本操作：初始化，创建新表，删除元素，插入元素，定位元素，打印顺序表，返回长度

该程序实现了一个顺序表的基本操作：

int InitList_Sq();          //初始化线性表
void CreateSqList();        //创建线性表
void ListInsert();          //向线性表中插入值
void ListDelete();          //删除顺序表中的数据元素
void PrintList();           //打印顺序表
int Locate();               //定位数据元素
int ListLength();           //返回线性表L的长度

源代码为： 

#include<stdio.h>//标准头文件
#include<stdlib.h>//包含exit()函数
#include<conio.h>//包含getch()

#define LIST_INIT_SIZE 100   //线性表存储空间的初始分配量
#define LISTINCREMENT 10     //线性表存储空间的分配增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int ElemType;        //顺序表存放的是整数
typedef struct
{
	ElemType *elem;         //存储空间基址
	int length;             //当前长度
	int listsize;           //当前分配的存储容量（以sizeof(ElemType)为单位）
}SqList;
int InitList_Sq();          //初始化线性表
void CreateSqList();        //创建线性表
void ListInsert();          //向线性表中插入值
void ListDelete();          //删除顺序表中的数据元素
void PrintList();           //打印顺序表
int Locate();               //定位数据元素
int ListLength();           //返回线性表L的长度


//初始化线性表
int InitList_Sq(SqList &L)
//操作结果：构建一个新的顺序表，为顺序表分配一个预定义大小的数组空间，并为顺序表当前的长度设置为“0”
{
	L.elem = (ElemType *) malloc (LIST_INIT_SIZE * sizeof(ElemType));//为顺序表分配一个预定义大小的数组空间
	if (!L.elem)                        //存储空间分配失败
	{
		exit(OVERFLOW);      
	}
	L.length = 0;                           //空表长度为0
	L.listsize = LIST_INIT_SIZE;            //初始化存储空间
	return OK;
}//InitList_Sq


//创建线性表
void CreateSqList(SqList &L, int m)
//初始条件：顺序表L已经存在
//操作结果：将m个元素一次加入到顺序表L中
{
	int i;
	for (i = 0; i < m; i++)
	{
		scanf("%d", &L.elem[i]);
		L.length++;
		if(L.length >= L.listsize)
		{
			L.elem = (ElemType *) realloc (L.elem,(L.listsize+LISTINCREMENT)* sizeof(ElemType));
			L.listsize += LISTINCREMENT;
		}
	}
}//CreateSqList


//向线性表中插入值
void ListInsert(SqList &L,int i,ElemType e)
//初始条件：顺序表L已存在，1<=i<=L.length+1
//操作结果：在L中的第i个位置前插入新的数据元素e，L的长度+1
{
	ElemType *p,*q;
	if(i < 1 || i > L.length+1)    //存储空间分配失败
	{
		exit (OVERFLOW);
	}
	if(L.length >= L.listsize)
	{
		L.elem =( ElemType *) realloc (L.elem,(L.listsize+LISTINCREMENT)* sizeof(ElemType));
		L.listsize += LISTINCREMENT;
	}
	q = &(L.elem[i-1]);
	for(p = &(L.elem[L.length-1]);p >= q; --p)
	{
		*(p+1) = *p;
	}
	*q = e;
	++L.length;
}//ListInsert


//删除线性表中的元素
void ListDelete(SqList &L,int i,ElemType e)
//初始条件：线性表L已存在且非空，1<=i<=L.length
//操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
{
	ElemType *p;
	if(i < 1 || i > L.length+1)    //存储空间分配失败
	{
		exit (OVERFLOW);
	}
	e = L.elem[i-1];
	for (p=&L.elem[i-1]; p <= &L.elem[L.length-1]; p++)
	{
		*(p-1) = *p;
	}
	L.length--;
}//ListDelete


//打印顺序表
void PrintList(SqList L)
//初始条件：线性表L已存在
//操作结果：打印顺序表
{
	int i;
	for (i = 0;i < L.length; i++)
	{
		printf("%d  ",L.elem[i]);
	}
}//PrintList


//定位数据元素
int Locate(SqList L,ElemType e) 
//初始条件：线性表L已存在
//操作结果：若顺序表中存在数据元素e，则返回e在顺序表中L中第一次出现的位序，否则返回0
{
	int i,result =0;
	for (i = 0;i < L.length; i++)
	{
		if(L.elem[i] == e)
		{
			result = i+1;
			break;
		}
	}
	return result;

}//Locate

//返回顺序表的长度
int ListLength(SqList L)
//初始条件：顺序表L已存在
//操作结果：返回顺序表L的长度
{
	return L.length;
}//ListLength


void main()
{
	SqList L;          //定义顺序表为L
	int n,i;           //n顺序表的表长,i存放元素的位置
	ElemType e;        //顺序表中每一个元素
	InitList_Sq(L);
	printf("请输入表长：");
	scanf("%d",&n);
	printf("输请入元素，中间使用空格分离：");
    CreateSqList(L,n);
	printf("顺序表为：");
	PrintList(L);
	printf("\n");
	printf("输入插入位置和元素，中间使用空格分离：");
	scanf("%d %d",&i,&e);
	ListInsert(L,i,e);
	printf("顺序表为：");
	PrintList(L);
	printf("\n");
	printf("请输入要删除元素的位置：");
	scanf("%d",&i);
	ListDelete(L,i,e);
	printf("删除的元素为：%d\n",e);
	printf("请输入待查找的元素：");
	scanf("%d",&e);
	printf("查找结果为：%d\n",Locate(L,e));
	printf("顺序表的表长为：%d\n",ListLength(L));
	printf("按任意键结束\n");
	char ch = getch();
}