线性表的顺序表示和实现

线性表的动态分配顺序存储结构

#define LIST_INIT_SIZE 10//线性表存储空间的初始分配量
#define LIST_INCREMENT 2//线性表存储空间的分配增量
struct SqList
{
    ElemType * elem;//存储空间基址
    int length;//当前长度
    int listsize;//当前分配的存储容量（以sizeof(ElemType)为单位）
};

顺序存储的线性表的12个基本操作

void InitList(SqList &L){//操作结果：构造一个空的顺序线性表Lad
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!L.elem)exit(OVERFLOW);//存储分配失败
    L.length = 0;//空表长度为0
    L.listsize = LIST_INIT_SIZE;//初始存储容量
}

void DestroyList(SqList &L){//初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表
    free(L.elem);//释放L.elem所指的存储空间
    L.elem = NULL;//L.elem不再指向任何存储单元
    L.length = 0;
    L.listsize = 0;
}

void ClearList(SqList &L){//初始条件：顺序线性表L已存在。操作结果：将L重置为空表
    L.length = 0;
}

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

int ListLength(SqList L){//初始条件：顺序线性表已存在。操作结果：返回L中数据元素的个数
    return L.length;
}

Status GetElem(SqList L, int i, ElemType &e){//初始条件：顺序线性表已存在，1<=i<=ListLength(L)操作结果：用e返回L中第i个数据元素的值
    if (i < 1 || i > L.length) return ERROR;//i不在表L的范围之内
    e = *(L.elem + i - 1);//将表L的第i个元素的值赋给e
    return OK;
}

int LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType)){
    //初始条件：顺序线性表L已存在，compare()是数据元素判定的函数
    //操作结果：返回L中第1个与e满足关系compare()的数据元素的位序
    //若这样的元素不存在，则返回0
    int i = 1;//i的初值为第1个元素的位序
    ElemType *p = L.elem;//p的初值为第1个元素的存储位置
    while (i <= L.length && !compare(*p++, e))//i未超出表的范围且未找到满足关系的数据元素
        ++i;//继续向后找
    if (i <= L.length) return i;//找到满足其关系的数据元素，返回其位序
    else return 0;//未找到满足关系的数据元素
}

Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e){
    //初始条件：顺序线性表L已存在。
    //操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
    int i = 2;//从第2个元素开始
    ElemType *p = L.elem + 1;//p指向第2个元素
    while (i <= L.length && *p != cur_e){//i未超出表的范围且未找到值为cur_e的数据元素
        p++;//p指向下一个元素
        i++;//计数+1
    }
    if (i > L.length) return ERROR;//到表结束还未找到值为cur_e的元素，操作失败
    else {//找到值为cur_e的元素，并由p指向其
        pre_e = *--p;//p指向前一个元素（cur_e的前驱），将所指元素的值赋给pre_e
        return OK;//操作成功
    }
}

Status NextElem(SqList L, ElemType cur_e, ElemType &next_e){
    int i = 1;
    ElemType *p = L.elem;
    while (i <= L.length && *p != cur_e){
        p++;
        i++;
    }
    if (i == L.length) return ERROR;
    else {
        next_e = *++p;
        return OK;
    }
}

Status ListInsert(SqList L, int i, ElemType e){
    ElemType *newbase, *q, *p;
    if (i<1 || i > L.length + 1) return ERROR;
    if (L.length = L.listsize){
        newbase = (ElemType *)realloc(L.elem, (L.listsize + LIST_INCREMENT) * sizeof(ElemType));
        if (!newbase)exit(OVERFLOW);
        L.elem = newbase;
        L.listsize += LIST_INCREMENT;
    }
    q = L.elem + i - 1;
    for (p = L.elem + L.length - 1; p >= q; --p){
        *(p + 1) = *p;
        *q = e;
        ++L.length;
        return OK;
    }
}

Status ListDelete(SqList L, int i, ElemType &e){
    ElemType *q, *p;
    if (i<1 || i > L.length) return ERROR;
    q = L.elem + i - 1;
    q = L.elem + L.length - 1;
    for (p = L.elem + i; p <= q; ++p)
        *(p - 1) = *p;
    return OK;
}

void ListTraverse(SqList L, void(*visit)(ElemType&)){
    ElemType *p = L.elem;
    int i;
    for (i = 1; i <= L.length; i++)
        visit(*p++);
    printf("\n");
}

几个常用的函数

Status equal(ElemType c1, ElemType c2){//判断是否相等的函数
    if (c1 == c2)
        return TRUE;
    else
        return FALSE;
}

int comp(ElemType a, ElemType b){//根据值，返回0,-1,1
    if (a == b)
        return 0;
    else
        return (a - b) / abs(a - b);
}

void print(ElemType e){//以十进制整型的格式输出元素的值
    printf("%d", e);
}

void print1(ElemType &e){//以十进制整型的格式输出元素的值（c为引用）
    printf("%d", e);
}

void print2(ElemType e){//以字符型的格式输出元素的值
    printf("%c", e);
}