顺序表——动态分配和静态分配

静态分配

数组采用静态分配时，数组的大小和空间事先已经固定，一旦空间占满，再新加入数据就会溢出，导致程序崩溃。

//顺序表——静态分配 
#include <stdio.h>
#define MaxSize 10        //定义顺序表的最大长度 

//定义
typedef struct{
    int data[MaxSize];        //使用数组存放数据元素 
    int length;                //顺序表当前的长度 
}SqList;

//初始化——1、将顺序表的所有数据元素初始化为0；2、将顺序表的初始长度设为0 
void InitList(SqList &L){        //参数为SqList类型，需要& 
    for(int i=0;i<MaxSize;i++){
        L.data[i]=0;        //将顺序表的所有数据元素初始化为0
    }
    L.length=0;        //将顺序表的初始长度设为0
}

//插入 ——在位置i插入元素e 
bool ListInsert(SqList &L,int i,int e){
    if(i<1||i>L.length+1)
        return false;
    if(i>=MaxSize)
        return false;
    for(int j=L.length;j>=i;j--){
        L.data[j]=L.data[j-1];        //最好时间复杂度为O(1),最坏和平均为O(n)
    } 
    L.data[i-1]=e;
    L.length++;        //插入后表的长度+1 
    return true;
} 

//删除——删除第i个元素 
bool ListDelete(SqList &L,int i){
    if(i<1||i>L.length)
        return false;
    for(int j=i;j<L.length;j++){
        L.data[j-1]=L.data[j];        //最好时间复杂度为O(1),最坏和平均为O(n) 
    } 
    L.length--;
    return true;
} 

//查找——按值查找
int LocateElem(SqList L,int e){
    for(int i=0;i<L.length;i++){
        if(L.data[i]==e)
            printf("该元素为第%d个元素",i+1);
    }
    return 0;
} 
int main(){
    SqList L;            //定义 
    InitList(L);        //初始化，此处不需要& 
    ListInsert(L,1,5);    //在位置1插入元素5
    ListInsert(L,2,6);    //在位置2插入元素6
    for(int i=0;i<L.length;i++){
        printf("插入后的顺序表第%d个元素为：%d\n",i,L.data[i]);
    }
    ListDelete(L,2);    //删除第2个元素 
    for(int i=0;i<L.length;i++){
        printf("删除后的顺序表为：%d\n",L.data[i]);
    }
    LocateElem(L,5);
    return 0;
} 

动态分配

数组采用动态分配时，空间在程序执行过程中可以通过动态存储分配语句分配，不需要一次性为线性表划分所有的空间。

//顺序表——动态分配
#include <stdio.h>    
#include <stdlib.h>        //使用malloc、free的头文件 
#define InitSize 10        //默认最大长度 

//定义
typedef struct{
    int *data;        //指示动态数组的指针
    int MaxSize;    //顺序表的最大容量 
    int length;     //顺序表的当前长度 
}SeqList;

//初始化——使用malloc函数动态申请内存
void InitList(SeqList &L){
    L.data=(int *)malloc(InitSize*sizeof(int));        //使用malloc函数动态申请内存
    L.length=0;        //当前长度设为0 
    L.MaxSize=InitSize;        //默认最大长度 
} 

//动态增加数组长度
void IncreaseList(SeqList &L,int len){
    int *p=L.data;        //将数组中的数据暂时存放到指针p
    L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));        //重新申请内存
    for(int i=0;i<L.length;i++){
        L.data[i]=p[i];        //复制数据 
    } 
    L.MaxSize=L.MaxSize+len;
    free(p); 
} 

//插入
bool ListInsert(SeqList &L,int i,int e){
    if(i<1||i>L.length+1)
        return false;
    if(i>=L.MaxSize)
        return false;
    for(int j=L.length;j>=i;j--){
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;
    L.length++;
    return true;
} 

//删除
bool ListDelete(SeqList &L,int i){
    if(i<1||i>L.length)
        return false;
    for(int j=i;j<L.length;j++){
        L.data[j-1]=L.data[j];
    }
    L.length--;
    return true;
} 

//按值查找
void LocateElem(SeqList L,int e){
    for(int i=0;i<L.length;i++){
        if(L.data[i]==e)
            printf("元素%d是第%d个元素",e,i+1);
    }
} 
int main(){
    SeqList L;
    InitList(L);
//    IncreaseList(L,10);    //动态增加数组长度
    ListInsert(L,1,5);    //在位置1插入元素5
    ListInsert(L,2,6);    //在位置2插入元素6
    for(int i=0;i<L.length;i++){
        printf("插入后的顺序表第%d个元素为：%d\n",i,L.data[i]);
    }
    ListDelete(L,2);    //删除第2个元素 
    for(int i=0;i<L.length;i++){
        printf("删除后的顺序表为：%d\n",L.data[i]);
    }
    LocateElem(L,5);
    return 0;
}