顺序表

 顺序线性表其存储结构是连续内存空间，所以查询操作（改、查）时间复杂度为O（1），数据操作（增、删）时间复杂度为O（n）

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

#define TRUE 1
#define FALSE 0
#define OK	1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

// Status是函数的类型，其值是函数结果状态代码
typedef int Status;

#define LIST_INTI_SIZE 100		// 线性表存储空间的初始分配量
#define LISTINCREMENT 10		// 线性表存储空间的分配增量

typedef int ElemType;

typedef struct {
	ElemType * elem;		// 存储空间基址
	int length;			// 当前长度
	int listsize;		// 当前分配的存储容量（以sizeof(ElemType)为单位）
}SqList;

Status InitList_Sq(SqList &L) {
	// 构造一个空的线性表L
	L.elem = (ElemType *)malloc(LIST_INTI_SIZE * sizeof(ElemType));
	if (!L.elem) exit(OVERFLOW);	// 存储分配失败
	L.length = 0;					// 空表长度为0
	L.listsize = LISTINCREMENT;		// 初始存储容量
	return OK;
}	// InitList_Sq

Status ClearList(SqList &L) {
	// 初始条件：线性表L已经存在
	// 操作结果：将L重置为空表
	free(L.elem);	// 释放空间
	L.length = 0;
	L.listsize = 0;
}

Status ListEmpty(SqList &L) {
	// 初始条件：线性表L已经存在
	// 操作结果：若L为空表，则返回TRUE, 否则返回FALSE
	if (L.elem == NULL) return ERROR;
	if (L.length == 0) return TRUE;
	return FALSE;
}

ElemType ListLength(SqList &L) {
	// 初始条件：线性表L已存在，1 <= i <= ListLength(L)
	// 操作结果：返回L中数据元素的个数
	if (L.elem == NULL) return ERROR;
	return L.length;
}

ElemType GetElem(SqList &L, int i, ElemType &e) {
	// 初始条件：线性表L已存在，1 <= i <= ListLength(L)
	// 操作结果：用e返回L中第i个数据元素的值
	if (L.elem == NULL) return ERROR;
	e = L.elem[i];
}

Status ListInsert_Sq(SqList &L, int i, ElemType e) {
	// 在顺序线性表L中第i个位置之前插入新的元素e
	// i的合法值为 1 <= i <= ListLength_Sq(L) + 1
	if ((i < 1)| (i > L.length + 1)) return ERROR;		// i值不合法
	if (L.length >= L.listsize) { 
		Status *newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase) exit(OVERFLOW);	// 存储分配失败
		L.elem = newbase;			// 新基址
		L.listsize += LISTINCREMENT;	// 增加存储容量
	}
	ElemType *q = &(L.elem[i - 1]);
	for (ElemType *p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;
	*q = e;		// 插入e
	++L.length;		// 表增长1
	return OK;
}

Status ListDelete_Sq(SqList &L, int i, ElemType &e) {
	// 在顺序线性表L中删除第i个元素，并用e返回其值
	// i的合法值为 1 <= i <= ListLength_Sq(L)
	if ((i < 1) || (i > L.length)) return ERROR;	// i值不合法
	ElemType *p = &(L.elem[i - 1]);		// p为被删除元素的位置
	e = *p;		// 被删除元素的值赋给e
	ElemType *q = L.elem + L.length - 1;		// 表尾元素的位置
	for (++p; p <= q; ++p) *(p - 1) = *p;		// 被删除元素之后的元素左移
	--L.length;		// 表长减一
	return OK;
}//ListDelet_Sq

int LocateElem_Sq(SqList L, ElemType e, Status(*compare)(ElemType, ElemType)) {
	// 在顺序线性表L中查找第1个值与e满足compare()的元素的位序
	// 若找到，则返回其在L中的位序，否则返回0
	ElemType i = 1;		// i的初值为第1个元素的位序
	ElemType *p = L.elem;	// p的初值为第1个元素的存储位置
	while (i <= L.length && !(*compare)(*p++, e)) ++i;
	if (i <= L.length) return i;
	else return 0;
}//LocateElem_Sq

Status compare(ElemType e1, ElemType e2) {
	if (e1 == e2) {
		return true;
	}
	return false;
}

void MergeList_Sq(SqList La, SqList Lb, SqList &Lc) {
	//已知顺序线性表La和Lb的元素按值非递减排列
	// 归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列
	Status *pa = La.elem; Status *pb = Lb.elem;
	Lc.listsize = Lc.length = La.length + Lb.length;
	ElemType *pc = Lc.elem = (ElemType *)malloc(Lc.listsize * sizeof(ElemType));
	if (!Lc.elem) exit(OVERFLOW);
	ElemType *pa_last = La.elem + La.length - 1;
	ElemType *pb_last = Lb.elem + Lb.length - 1;
	while (pa <= pa_last && pb <= pb_last) {	// 归并
		if (*pa <= *pb) *pc++ = *pa++;
		else *pc++ = *pb++;
	}
	while (pa <= pa_last) *pc++ = *pa++;	// 插入La的剩余元素
	while (pb <= pb_last) *pc++ = *pb++;	// 插入Lb的剩余元素
}//MergeList_Sq

void listunion(SqList La, SqList Lb) {
	//将所有在线性表Lb中但不在La中的数据元素插入到La中
	ElemType e, La_len = ListLength(La); ElemType Lb_len = ListLength(Lb); // 求线性表的长度
	for (int i = 1; i <= Lb_len; i++) {
		GetElem(Lb, i, e);
		if (!LocateElem_Sq(La, e, compare)) ListInsert_Sq(La, ++La_len, e);	// La中不存在和e相同的数据元素，则插入之
	}
}