数据结构中线性表的顺序式表示的基本操作函数

线性表的基本操作共有十二个。我们通过对线性表基本操作的有机组合，可以处理较为复杂的线性表。

一、初始化顺序线性表——构造一个空的顺序线性表

void InitList(SqList &L)
{
       L.elem = (ElemType*)malloc(LIST_INIT_SIZE *sizeof(ELemType));//malloc函数来分配存储空间
       if(!L.elem)//分配存储失败
       {
            exit(OVERFLOW);
       }
       L.length = 0;//空表的长度为0
       L.listsize = LIST_INIT_SIZE;//初始的存储容量等于LIST_INIT_SIZE
}        

顺序表初始化的基本步骤：

1、开辟存储空间，使用malloc函数，个数为LIST_INIT_SIZE,每个存储元素的大小为sizeof(ElemType);

2、初始化当前的表长为0；

3、初始的存储容量为LIST_INIT_SIZE

二、销毁顺序线性表

void DestoryList(SqList &L)
{
    free(L.elem);//释放L.elem所指的存储空间
    L.elem = NULL;//L.elem不再指向任何存储单元
    L.length = 0;//顺序表的长度置零
    L.listsize = 0;//顺序表的大小也置为零
}

销毁顺序表的步骤：

1、用free(L.elem)释放指针所指的存储空间；

2、指针不指向任何东西，即L.elem = NULL

3、将顺序表的表长和存储容量都置为零

三、重置顺序线性表为空

void ClearList(SqList &L)
{
    L.length = 0;//直接把当前表长置为零，判断元素的的个数就是通过当前表长来判断的
}

注：顺序表的当前表长已经置零，如果要存储数据的话，仍然从elem[0]开始存储，新的数据将直接覆盖原来指针中所包含的数据

四、判断顺序线性表是否为空

Status ListEmpty(SqList L) 
{
    if(L.Length == 0)//如果是零返回TRUE,这里是宏定义，TRUEdai表1,FALSE 代表0
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
]

注：Status 也是宏定义，这里代表的就是 int 整形

五、求顺序线性表中元素的个数

Status ListLength(SqList L)
{
    return L.length;//L.length中的值代表的就是顺序表中元素的个数
}

六、获取顺序线性表中第i个元素的值

Status GetElem(SqList L,int i,ElemType &e)
{
    if(i < 1 || i > L.length)//i 不在L的范围之内
    {
        return ERROR;
    }
    e = *(L.elem + i - 1);//将L的第i个元素值赋给e
}

七、确定顺序表中与元素e满足compare()函数的关系

int LocateElem(SqList L,ElemType e,Status *(compare)(ElemType ,ElemType))
{
    int i = 1;//i的初值为第一个元素的位序
    ElemType *p = L.elem;//p指向第一个元素
    while(i <= L.length && !compare(*p ++,e))//i没有超出表的范围并且未找到满足关系的元素
    {
        i ++;
    }
    if(i <= L.length)//找到满足关系的元素
    {
        return i;//返回其位序
    }
    else//未找到满足关系的数据
    {
        return 0;
    }
}

注：compare()是一个函数，在其中可以定义两个元素的某种关系，比如相等、二倍等等。

八、cur_e是L中的元素，且不是第一个，用pre_e返回它的前驱

Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e)// 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
{
    int i = 2;//从第二个元素开始
    ElemType *p = L.elem + 1;//p指向第二个元素
    while (i < L.length && *p != cur_e)//i未超出表的范围，且未找到cure_e
    {
        p++;//p 指向下一个元素
        i++;//计数加一
    }
    if (i > L.length)//到表结束还没有找到cure_e的元素
    {
        return ERROR;
    }
    else
    {
        pre_e = *--p;//如果成功p指向钱一个元素
        return OK;
    }
}

九、cur_e是L中的元素，且不是最后一个，用next_e返回它的前驱

Status NexElem(SqList L, ElemType cur_e, ElemType &next_e)//若cur_e是L中的元素，且不是最后一个，则用next_e返回他的后继，否则操作失败，无定义
{
    int i = 1;//从第一个元素开始
    ElemType *p = L.elem;//p指向第一个元素
    while (i < L.length && *p != cur_e)//i未找到值为cur_e的元素
    {
        p++;//p 指向下一个元素
        i++;//计数加一
    }
    if (i == L.length)//到表尾还么有找到元素
    {
        return ERROR;
    }
    else
    {
        next_e = *++p;//p指向下一个元素，将所指的元素的值赋给next_e
        return OK;
    }
}

十、插入元素

Status ListInsert(SqList &L, int i, ElemType e)//在L中第i个位置插入e
{
    ElemType *newbase, *q, *p;
    if (i < 1 || i > L.length)
    {
        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.elem
        L.listsize += LIST_INCREMENT;//增加存储容量
    }
    q = L.elem + i - 1;
    for (p = L.elem + L.length - 1; p >= q; --p)//移位
    {
        *(p + 1) = *p;
    }
    *q = e;//插入e
    L.length++;//表长加一
    return OK;
}

十一、删除元素

Status ListDelete(SqList &L, int i, ElemType &e)//删除第i个元素，并用e返回其值
{
    ElemType *p, *q;
    if (i < 1 || i > L.length)//i值不合法
    {
        return ERROR;
    }
    p = L.elem + i - 1;//p为被删除元素的位置
    e = *p;//被删除元素值赋给e
    q = L.elem + L.length - 1;//q为表尾元素的位置
    for (p++; p <= q; p++)
    {
        *(p - 1) = *p;
    }
    L.length--;
    return OK;
}

十二、依次对每个数据元素调用visit()函数

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