数据结构——线性表

（一）线性表的基本概念

         1.1  线性表定义   

        线性表：具有相同数据类型（所占用空间相同）的n个数据元素的有限序列，其中n为表长，可表示为

L=（a1，a2，a3，···，ai，···an）

• 位序从1开始，区别于数组下标从0开始
• a1，第一个数据元素，表头
• an，最后一个元素数据，表尾
• 每一个元素有且仅有一个直接前驱（除第一个元素）
• 每一个元素有且仅有一个直接后继（除最后一个元素）
• 特点：

        1）元素个数有限

        2）逻辑上有序，元素有先后次序

        3）元素是数据元素，每个元素是单个数据

        4）表中数据类型相同，占有相同大小存储空间

        5）抽象性，只考虑逻辑关系

PS：线性表是逻辑结构

         顺序表和链表是存储结构

        1.2 线性表基本操作

        “创销，增删改查”

        基本操作：（抽象接口，未指明数据类型）

InitList（&L）：初始化表，构造一个空表

Length（L）：求表L的长度

LocateElem（L，e）：按值查找

GetElem（L，i）：按位查找

ListInsert（&L，i，e）：插入

ListDelete（&L，i，&e）：删除

PrintList（L）：打印

Empty（L）：判空

DestroyList（L）：销毁

        其中：“&”为引用

（二）线性表的顺序表示

        2.1 顺序表定义

        一组地址连续的存储单元依次存储线性表中的数据元素，使得其逻辑上相邻的两个元素在物理位置上也相邻

        

        特点：元素的逻辑顺序与其存储的物理顺序相同

        2.2 顺序表实现

        静态分配

        特点：长度、大小固定

//定义数据结构
#define MaxSize 10             //定义最大长度
typedef struct{
    Elemtype data[MaxSize];    //静态数组存放数据
    int length;                //顺序表当前长度
}SqList;                       //顺序表定义类型

//基本操作——初始化（否则脏数据）
void InitList（SqList &L）{
    for(int I=0;i<MaxSize;i++){
        L.data[I]=0;           //初始化数据元素
    }
    L.length=0;                //顺序表长度为0
}

int main(){
    SqList L;                 //声明
    InitList(L);              //初始化
    return 0;
}

        如果“数组”存满了就不能再加入新数据，否则程序崩溃

        动态分配

//定义数据结构
#define InitSize 10             //定义初始长度
typedef struct{
    Elemtype *data;            //静态数组存放数据
    int MaxSize；              //顺序表的最大容量
    int length;                //顺序表当前长度
}SqList;                       //顺序表定义类型（动态）

//基本操作——初始化
void InitList（SqList &L）{
    //malloc 申请一块连续的空间
    L.data = （ElemType *）malloc（InitSize*sizeof（ElemType））；
    L.length= 0；
    L.MaxSize=InitSize;
}

//动态申请新的长度,增加长度len
void IncreaseSize（SqList &L，int len）{
    ElemType *p = L.data;
    L.data = （ElemType *）malloc（(L.MaxSize+len)*sizeof（ElemType））；
    for(int i=0;i<L.length;i++){
        L.data[i]=p[I];       //数据复制到新的空间，时间开销大
    }
    L.MaxSize=L.MaxSize+len;
    free(p);
}


int main(){
    SqList L;                 //声明
    InitList(L);              //初始化

    IncreaseSize（L，6）；     //多申请6个数据空间
    return 0;
}

PS：动态申请与释放内存空间

        malloc（）：malloc返回一个指针，需要强制转化为定义的ElemType类型指针，参数决定内存大小

L.data = （ElemType *）malloc（sizeof（ElemType）*InitSize）；

        free（）

Elemtype *data;         指针，顺序表中的第一个元素

int MaxSize；              动态申请，使用MaxSize表示顺序表的最大容量

        顺序表的特点

        随机访问；存储密度高；拓展容量不方便；插入删除不方便

2.3 顺序表的基本操作

//定义数据结构
#define MaxSize 10             //定义最大长度
typedef struct{
            int data[MaxSize];    //静态数组存放数据
            int length;                             //顺序表当前长度
}SqList;                                             //顺序表定义类型        

        2.3.1 插入

        ListInsert（&L，i，e）：插入，在表L中第i个位置上插入元素e

bool ListInsert(SqList &L,int i,int e){
    if(i<1 || i>L.length+1)         //判断i的范围是否有效
        return false；
    if(L.length>=MaxSize)           //当前存储空间已满，不能插入
        return false；
    
    for(int j=L.length;j>=I;j--){        
        L.data[j]=L.data[j-1];      //将第i个元素及之后的元素后移
    }
    L.data[i-1]=e;                  //将e放在位置i上（下标与位序相差1）
    L.length++;                     //长度加1
    return true;
}

        最好情况：表尾插入（i=n+1），元素后移语句不再执行，时间复杂度O（1）

        最坏情况：表头插入（i=1），元素后移语句执行n次，时间复杂度O（n） 

        平均情况：   O(n)   

        2.3.2 删除

        ListDelete（&L，i，&e）：删除，在表L中删除第i个元素并返回到e中（引用修改e）

bool ListDelete(SqList &L,int I,int &e){
    if(i<1 || i>L.length){         //判断i的范围是否有效
        return false;
    }
    e = L.data[i-1];               //将被删除元素的值赋值给e
    for(int j=I;j<L.length;j++){   //将第i个位置后的元素前移
        L.data[j-1] = L.data[j];
    }
    L.length--;                    //线性表的长度减1
    return true;
}

        最