＜数据结构＞动态分配内存的顺序表实现(C语言）

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define InitSize 15

typedef struct {

   int *data;
   int MaxSize,length;
}SeqList;




int InitSeqList(SeqList *L){
    L->data=(int *)malloc(sizeof(int)*InitSize);
    if(!L->data)return 0;
    L->length=0;
    L->MaxSize=InitSize;
    printf("该顺序表已被创建\n\n");
    return 1;
}

int DestroyLIst(SeqList *L){//因为此处采用了顺序表的动态内存分配所以要使用malloc()和free()函数成对申请和销毁内存空间
    if(!L)return 0;

    else {free(L->data);printf("该顺序表已销毁\n\n");}
    return 1;
}



int ListInsert(SeqList *L,int i,int e){//i 的取值有n+1种 即n=L,leng  问题规模即当前表长;
                                        //最好循环语句执行次数 当i=length+1 第一次for循环判定j=L-<length<i=length+1 最好事件复杂度 T(n)=O(1);
                                        //最坏循环语句执行次数 当i=1 for循环语句执行 j由length到1 共n次 T(n)=O(n);
                                        //平均时间复杂都为 E(T(n))=(  1/n+1  )*(0+2+3+...+n)=(  1/n+1  )*(0 + n)*(n+1)/2=n/2=O(n) 顺序表平均时间复杂度仍为O(n)

    if(i<1||i>L->length+1)
        return 0;//顺序表的插入操作i的合法取值为1到L.length+1
    if(L->length>=InitSize)return 0;


    int j=L->length;
    int times=0;//times 用以记录循环语句执行次数
    for(;j>=i;j--){
        L->data[j]=L->data[j-1];times++;}
    L->data[i-1]=e;
    L->length++;
    printf("向顺序表位置:%d插入元素:%d成功\n循环执行：%d次\n\n",i,e,times);
    return 1;

    }

int ListDelete(SeqList *L,int i,int *e){ //i的取值有n种 即n=L.length 问题规模即当前表长
    if(!L)                               //最好循环语句执行次数 当i=length 第一次for循环判定j=L-<length<i=length 最好事件复杂度 T(n)=O(1);
       return 0;                        //最坏循环语句执行次数 当i=1 for循环语句执行 j由1到L->length-1 共n-1次 T(n)=O(n-1)=O(n);
    if(i<1||i>L->length)               //平均时间复杂度 E(T(n))=(  1/n  )*(0+2+3+...+n-1)=(  1/n  )*(0 + n-1)*(n)/2=(n-1)/2=O(n)
       return 0;
    int j=i;
    int times=0;//times 用以记录循环语句执行次数
    (*e)=L->data[i-1];
    for(;j<L->length;j++)
        L->data[j-1]=L->data[j];
    L->length--;
    printf("向顺序表位置:%d删除元素:%d成功\n循环执行：%d次\n\n",i,(*e),times);

    return 1;


}

void PrintList(SeqList *L){
    for(int i=0;i<L->length;i++)
        printf("该顺序表中第%d个元素%d\n",i+1,L->data[i]);

}


int GetElem(SeqList *L,int i){//顺序表具有随机存取的特点 在 O(1)的时间复杂度下可以实现按位存取

    if(i<1||i>L->length)
        return 0;
    return (L->data[i-1]);




}

int LocatElem(SeqList L,int e){//此时for循环语句的执行次数和顺序表内元素值相关
   if(L.length==0)return 0;   //最好时间复杂度 当第1位元素恰为按值查找时循环语句执行次数为:1 O(n)=1
   int i=0;                   //最坏时间复杂度  当查找元素为最后一位元素或者不存在时 执行次数为:n O(n)=n
   for(;i<L.length;i++)      //平均时间复杂度   E(T(n))=(  1/n  )*(1+2+3+...+n)=(  1/n  )*(1 + n)*(n)/2=(n+1)/2=O(n)
   if(L.data[i]==e){printf("已在该顺序表中找到第:%d位元素：%d\n",i+1,e);break;}


   return i;

}


int main()
{

    SeqList L;

    int discard;
    int desert;

    InitSeqList(&L);

    ListInsert(&L,1,7);
    ListInsert(&L,1,7);
    ListInsert(&L,1,2);
    ListInsert(&L,1,5);
    ListInsert(&L,1,9);
    ListInsert(&L,1,9);

    PrintList(&L);

    ListDelete(&L,1,&discard);
    ListDelete(&L,5,&desert);

    PrintList(&L);
    printf("\n顺序表第1个节点数据为%d\n\n",GetElem(&L,1));
    if(!LocatElem(L,9))printf("顺序表按值查找失败\n\n");
    if(!LocatElem(L,9527))printf("顺序表按值查找失败\n");

    DestroyLIst(&L);
    return 0;
}