顺序线性表其存储结构是连续内存空间,所以查询操作(改、查)时间复杂度为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相同的数据元素,则插入之
}
}