线性表当中的顺序存储结构

顺序存储结构是线性表当中的物理存储结构之一，线性表的顺序存储结构指的是一段地址连续的存储单元依次存储线性表的数据元素

顺序存储方式就是在内存当中找了块地，通过占位的形式，把一定内存空间给占了，然后把相同数据类型的数据元素依次存放在这块空地当中

线性表当中的每个数据元素的类型都是相同的，所以我们可以用C语言的一维数组去实现这个顺序存储结构

下面就简单的介绍下其的结构的定义

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <cstdio>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

//存储空间初始分配量
#define MAXSIZE 20

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

/* ElemType类型根据实际情况而定，这里假设为int */
typedef int  ElemType;

typedef struct
{
    ElemType data[MAXSIZE];
    int length;
}SqList;

//初始化顺序线性表
Status InitList(SqList * L)
{
    L->length = 0;
    return OK;
}

//若L为空表，则返回TRUE，否则返回FALSE
Status ListEmpty(SqList L)
{
    if (L.length==0) {
        return TRUE;
    }
    else
        return FALSE;
}

//将L重置为空表
Status ClearList(SqList * L)
{
    L->length=0;
    return OK;
}

//如果顺序线性表存在，就返回L当中的数据元素个数
int ListLength(SqList L)
{
    return L.length;
}

//顺序线性表已经存在了，用e返回L当中的第i个位置
Status GetElem(SqList L,int i,ElemType *e)
{
   if(L.length==0||i<1 || i>L.length)
       return ERROR;

    *e=L.data[i-1];

    return OK;
}

//初始条件就是顺序表L已经存在
//返回L中第1个等于e的值
//如果这样的数据元素不存在的话，就返回0
int LocateElem(SqList L,ElemType e)
{
    int i;
    if(L.length==0)
        return 0;
    for (i=0;i<L.length; i++) {

        //如果存在了e的值
        if(L.data[i]==e)
            break;
    }
    if(i>=L.length)
        return 0;

    return i+1;
}
//当顺序线性表L存在的话
//将L中的第i个位置之前插入数据元素e，L的长度加1
Status ListInsert(SqList *L,int i,ElemType e)
{
    int k;
    if(L->length==MAXSIZE)
        return ERROR;

    //判断要插入的位置，如果要插入的位置小于1或者比线性表长度+1的位置还要大的话直接返回
    if(i<1 || i>L->length+1)
        return ERROR;
    //若插入数据位置不是在表尾的话，就要开始挪动元素
    if(i<=L->length)
    {

        for (k=L->length-1; k>=i-1; k--) {
            L->data[k+1] = L->data[k];
        }
    }
    L->data[i-1] = e;
    L->length++;
    return OK;
}

//删除线性表当中第i个数据元素，用e返回其值，L的长度减少1
Status ListDelete(SqList *L,int i,ElemType *e)
{
    int k;
    if (L->length==0) {
        return ERROR;
    }
    //删除的位置不正确
    if(i<1 || i>L->length)
        return ERROR;
    *e = L->data[i-1];
    //如果删除不是最后的位置
    if(i<L->length)
    {
        for (k=i; k<L->length; k++) {
            L->data[k-1]=L->data[k];
        }
    }
    L->length--;
    return OK;
}

//对L当中的每个数据元素输出
Status ListTraverse(SqList L)
{
    int i;
    for (i=0; i<L.length; i++) {
        printf("%d ",L.data[i]);
    }
    printf("\n");
    return OK;
}

void unionL(SqList *La,SqList Lb)
{
    int La_len,Lb_len,i;
    ElemType e;
    La_len = ListLength(*La);
    Lb_len = ListLength(Lb);

    for (i=1; i<=Lb_len; i++) {
        GetElem(Lb, i, &e);
        //判断元素是否存在
        if(!LocateElem(*La, e))
        {
            //插入元素
            ListInsert(La, ++La_len, e);
        }
    }
}

int main()
{

    SqList L;
    SqList Lb;

    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：L.length=%d\n",L.length);
    for(j=1;j<=5;j++)
        i=ListInsert(&L,1,j);
    printf("在L的表头依次插入1～5后：L.data=");

    ListTraverse(L);

    printf("L.length=%d \n",L.length);

    //判断表是否为空
    i=ListEmpty(L);

    printf("L是否空：i=%d(1:是 0:否)\n",i);
    //清空表
    i=ClearList(&L);
    printf("清空L后：L.length=%d\n",L.length);

    //判断表是否为空
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    //在表尾进行插入
    for(j=1;j<=10;j++)
        ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    //打印输出
    ListTraverse(L);
    printf("L.length=%d \n",L.length);

    //在表头插入0
    ListInsert(&L,1,0);
    printf("在L的表头插入0后：L.data=");
    //进行输出
    ListTraverse(L);
    printf("L.length=%d \n",L.length);

    //获取第五个元素的值
    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);

    for(j=3;j<=4;j++)
    {
        k=LocateElem(L,j);
        if(k)
            printf("第%d个元素的值为%d\n",k,j);
        else
            printf("没有值为%d的元素\n",j);
    }


    k=ListLength(L); /* k为表长 */

    for(j=k+1;j>=k;j--)
    {
        i=ListDelete(&L,j,&e); /* 删除第j个数据 */
        if(i==ERROR)
            printf("删除第%d个数据失败\n",j);
        else
            printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L);

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */

    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");

    ListTraverse(L);

    //构造一个有10个数的Lb
    i=InitList(&Lb);
    for(j=6;j<=15;j++)
        i=ListInsert(&Lb,1,j);

    unionL(&L,Lb);

    printf("依次输出合并了Lb的L的元素：");
    ListTraverse(L);

    return 0;
}

其实线性表的顺序存储结构在存、取数据的时候不管是在哪个位置，时间复杂度都是O(1)，而插入或删除的时候，时间复杂度都是O(n)，这就说明了其实这种顺序存储结构是比较适合元素个数不太变化，而更多是存取数据的应用

下面是线性表的顺序存储结构的优缺点