数据结构P1.1: 线性表-顺序表

线性表:概念和基本操作

• 线性表的逻辑结构：
  线性表是具有相同数据类型(每个数据元素所占的空间一样大)的n(n >=0)个数据元素的有限序列。
  直白理解：一条线串起了一个序列，上面的数据元素类型是相同的。各个数据元素之间有前后顺序。可以通过位序表示数据元素
  下图是一个长度为5的线性表
  
• 线性表的基本操作–创销、增删改查：

初始化：构建一个空的线性表，分配内存空间
销毁操作：销毁线性表并释放线性表所占的内存空间
插入操作：在表中的第 i 个位置上插入指定的元素a
删除操作：删除表中的第  i 个位置上元素，并用e返回删除元素的值
按值查找：在表中寻找给定关键值的元素
按位查找：获取表中第  i 个位置上元素的值

• 线性表的存储/物理结构：
  关注定义，如何用代码实现，基本操作如何实现
  分类：顺序表(顺序存储) 和链表(链式存储)：

线性表: 顺序表

• 顺序表概念：用顺序存储的结构实现的线性表。逻辑上相邻的元素存储在物理位置上相邻的存储单元中。
• 顺序表特性
  1.随机访问：可以随机访问第 i 个元素
  2.存储密度高：每个节点只存储数据元素
  3.扩展容量不方便：即便采用动态分配，时间开销也很大
  4.插入、删除操作不方便：需要移动大量元素、
• 顺序表优点：可随机存取（通过索引位序），存储密度高
• 顺序表缺点：占用大片连续空间，改变容量不方便

顺序表的实现：静态、动态存储

• 静态分配：通常用数组实现，大小一旦被定义不可改变。存储空间不可变即为静态的，这也是静态顺序表的局限
• 动态分配：顺序表的大小是可变的。需要借助指针，指向顺序表的第一个元素。代码实现中要动态申请和释放空间，借助malloc和free函数
• 代码实现顺序表

//顺序表的实现--静态分配  顺序表存储空间是静态不可变的

#define MaxSize 10              //定义最大长度，此长度不可变
typedef struct{
    元素变量类型 data[MaxSize]; //用数组实现静态存放数据元素,声明该语句时在内存中申请了一片连续的存储空间来存放数组元素
    int length;                 //顺序表的当前长度
}SqList;

//基本操作：初始化一个顺序表

void InitList(SqList){
    for(int i=0;i<MaxSize;i++)
        L.data[i]=0;            //将所有数据元素初始值设为0
    L.length=0;                 //顺序表初始值为0，因为开始的时候，顺序表中没有存放任何数据元素
}

int main(){
    SqList L;                   //声明一个顺序表，在内存中分配顺序表L的空间，包括MaxSize*sizeof(元素变量类型)和存储int length的空间
    InitList(L);                //初始化顺序表
    return 0;
}

//顺序表的实现--动态分配  顺序表存储空间是动态可变的

#define InitSize 10             //顺序表的初始长度，此长度可变
typedef struct{
    元素变量类型 *data          //指向顺序表中第一个数据元素
    int MaxSize;                /顺序表的最大容量
    int length;                 //顺序表的当前长度
}SqList;


//基本操作：初始化一个顺序表
void InitList(){
    //用malloc 函数动态申请一片连续的空间
    L.data=(元素变量类型 *)malloc(InitSize*sizeof(元素变量类型));   //指针data 指向申请空间的起始地址
    L.length=0;
    L.MaxSize=InitSize;
}

//基本操作：动态增加顺序表长度
void IncreaseList(SqList &L,int len){
    int *p=L.data;              //指针p和指针L.data指向同一个地址
    L.data=(元素变量类型 *)malloc((L.MaxSize+len))*sizeof(元素变量类型)); //新申请一片内存空间，存放之前最大容量和要增加的长度的总空间,此时里面没有任何数据元素
    //循环的条件是L.length，为了获得之前顺序表长度的数据
    for(int i=0;i<L.length);i++){
        L.data[I]=p[i];         //将数据复制到新区域，时间开销很大
    }
    L.MaxSize=L.MaxSize+len;    //顺序表最大长度增加了len
    free(p)；                   //释放原来的内存空间，即销毁
    
}

int main(){
    SqList L;                   //声明一个顺序表,和静态存储不同，声明该语句时，会在内存中申请存储元素变量类型 *data，int MaxSize和int length的空间
    InitList(L);                //初始化顺序表
    IncreaseList(L,5);          //增加顺序表长度,增加的长度为5
    return 0;
}

顺序表的插入删除和查找（代码）

#define MaxSize 10              //定义最大长度，此长度不可变
typedef struct{
    int data[MaxSize]; //用数组实现静态存放数据元素,声明该语句时在内存中申请了一片连续的存储空间来存放数组元素
    int length;                 //顺序表的当前长度
}SqList;

//基本操作：初始化一个顺序表

void InitList(SqList){
    for(int i=0;i<MaxSize;i++)
        L.data[i]=0;            //将所有数据元素初始值设为0
    L.length=0;                 //顺序表初始值为0，因为开始的时候，顺序表中没有存放任何数据元素
}

//基本操作：在表L中第i个位置插入元素e

bool InsertList(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--)    //实现插入，需要将第i个元素及之后的元素后移
        L.data[j]=L.data[j-1];      //前一个元素的值赋值给前一个元素
    L.data[i-1]=e;                  //在位置i处放入元素e
    L.length++;                     //长度加1
    return true;
}

//基本操作：删除表L中第i个位置的元素
bool DeleteList(SqList &L,int i,int &e){
    if(i<1||i>L.length)           //判断插入的位置i的值是否合法
        return false;
    e=L.data[i-1];                //将被删除的元素赋值给e
    for(j=i;j<=L.length;j++)      //将i位置后的元素依次前移
        L.data[j-1]=L.data[j];
    L.length--;                   //线性表长度-1
    return true;
}

//基本操作：按位查找，获取表中第i个位置上的元素的值
//静态查找
int GetElem(SqList L,int i)(
    return L.data[i-1];          //随机获取位置i上的元素
)
//动态查找
int GetElem(SqList L,int i)(
    return L.data[i-1];          //随机获取位置i上的元素，此时data为指针，指针加下标和访问数组一样
)

//基本操作：按值查找，在表L中查找给定值的元素
int LocateElem(SqList L,int e){
    for(int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;         //数组下标为i的元素，返回位置为i+1
    return 0;                   //退出循环，说明查找失败
}

int main(){
    SqList L;                   //声明一个顺序表，在内存中分配顺序表L的空间，包括MaxSize*sizeof(元素变量类型)和存储int length的空间
    InitList(L);                //初始化顺序表
    InsertList(L,3,3)           //在第3个位置插入数据元素3
    
    int e=-1;                   //用变量e把删除的元素带回来
    if (DeleteList(L,3,e))
        printf("成功删除第3个元素，删除的元素为%d\n",e);
    else
        printf("删除失败，原因：位置不合法")；
    return 0;
}