【数据结构】线性表的顺序表示

一、顺序表的定义

顺序表是用一组连续的存储单元依次存储线性表中的数据元素，从而实现逻辑上两个相邻的数据元素在物理位置上也相邻。

顺序表的逻辑顺序与物理顺序相同。

由上述可知：如果知道第一个顺序表的起始地址LOC(a1)，及每个元素所占内存空间大小sizeof(ElemType)，即可得出线性表中所有数据元素的地址。

计算公式：

注：ElemType的含义为所定义元素的类型。

易混淆：线性表中元素的位序是从1开始的，而数组中的元素的下标是从0开始的。

（1）顺序表的静态分配

#define InitSize 100            //顺序表最大长度
typedef struct{                 //顺序表的静态分配
    ElemType data[InitSize];    //顺序表元素
    int length;                 //顺序表当前长度
}SqList;                        //顺序表的类型定义

（2）顺序表的动态分配

#define InitSize 100            //初始表长
typedef struct{                 //顺序表的动态分配
    ElemType *data;             //存储空间的基地址
    int MaxSize,length;         //数组的最大容量及当前长度
}SeqList;                        //顺序表的类型定义



//C动态分配语句
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);

//C++动态分配语句
L.data=new ElemType[InitSize];

二、基本操作的实现

（1）初始化

①静态

void InitSqList(SqList &L){
    L.length=0;
}

②动态

void InitSeqList(SeqList &L){
    L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);
    L.length=0;
    L.MaxSize=InitSize;                                    //最大容量为初始容量
}

（2）插入操作

①空间已满，退出程序

#define FALSE 0;
#define TRUE 1;
bool ListInsert(SqList &L,int x,ElemType e){
    if(x<1||x>L.length+1)                    //判断所要插入位置是否合法
        return FALSE;
    if(L.length>=MaxSize)                    //空间是否已满
        return FALSE;
    for(int i=L.length;i>=x;i--){
        L.data[i]=L.data[i-1];
    }
    L.data[i-1]=e;
    L.length++;
    return TRUE;
}

②空间已满,增加分配

#define FALSE 0;
#define TRUE 1;
#define INCREASE 10;                         //分配增量
bool ListInsert(SqList &L,int x,ElemType e){
    if(x<1||x>L.length+1)                    //判断所要插入位置是否合法
        return FALSE;
    if(L.length>=MaxSize)                    //空间是否已满,若满则增加分配
        newbase=(ElemType*)realloc(L.data,(L.MaxSize+INCREASE)sizeof(ElemType));
        L.data=newbase;
    for(int i=L.length;i>=x;i--){
        L.data[i]=L.data[i-1];
    }
    L.data[i-1]=e;
    L.length++;
    return TRUE;
}

（3）删除操作

#define FALSE 0;
#define TRUE 1;
bool ListDelete(SqList &L,int x,ElemType e){
    if(x<1||x>L.length+1)                    //判断所要删除位置是否合法
        return FALSE;
    e=L.data[x-1];
    for(int i=x;i<L.length;i++){
        L.data[i-1]=L.data[i];
    }
    L.length--;
    return TRUE;
}

（4）按值查找

在顺序表中查找第一个元素值等于e的元素，并返回其位序

int LocateList(SqList L,ElemType e){
    for(int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;                //查找成功输出位序
    return 0;                          //查找失败退出循环
}

三、总结

全部代码

#define InitSize 100            //顺序表最大长度
typedef struct{                 //顺序表的静态分配
    ElemType data[InitSize];    //顺序表元素
    int length;                 //顺序表当前长度
}SqList;                        //顺序表的类型定义


#define InitSize 100            //初始表长
typedef struct{                 //顺序表的动态分配
    ElemType *data;             //存储空间的基地址
    int MaxSize,length;         //数组的最大容量及当前长度
}SeqList;                        //顺序表的类型定义



//C动态分配语句
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);

//C++动态分配语句
L.data=new ElemType[InitSize];


void InitSqList(SqList &L){
    L.length=0;
}


void InitSeqList(SeqList &L){
    L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);
    L.length=0;
    L.MaxSize=InitSize;                                    //最大容量为初始容量
}


#define FALSE 0;
#define TRUE 1;
bool ListInsert(SqList &L,int x,ElemType e){
    if(x<1||x>L.length+1)                    //判断所要插入位置是否合法
        return FALSE;
    if(L.length>=MaxSize)                    //空间是否已满
        return FALSE;
    for(int i=L.length;i>=x;i--){
        L.data[i]=L.data[i-1];
    }
    L.data[i-1]=e;
    L.length++;
    return TRUE;
}


#define FALSE 0;
#define TRUE 1;
#define INCREASE 10;                         //分配增量
bool ListInsert(SqList &L,int x,ElemType e){
    if(x<1||x>L.length+1)                    //判断所要插入位置是否合法
        return FALSE;
    if(L.length>=MaxSize)                    //空间是否已满,若满则增加分配
        newbase=(ElemType*)realloc(L.data,(L.MaxSize+INCREASE)sizeof(ElemType));
        L.data=newbase;
    for(int i=L.length;i>=x;i--){
        L.data[i]=L.data[i-1];
    }
    L.data[i-1]=e;
    L.length++;
    return TRUE;
}


#define FALSE 0;
#define TRUE 1;
bool ListDelete(SqList &L,int x,ElemType e){
    if(x<1||x>L.length+1)                    //判断所要删除位置是否合法
        return FALSE;
    e=L.data[x-1];
    for(int i=x;i<L.length;i++){
        L.data[i-1]=L.data[i];
    }
    L.length--;
    return TRUE;
}


int LocateList(SqList L,ElemType e){
    for(int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;                //查找成功输出位序
    return 0;                          //查找失败退出循环
}

---

本节只是讲解了顺序表重要基本操作的实现，其中有些代码为伪代码，需要修改后方可运行。