顺序表基本操作的实现

#include<stdio.h>
#include<stdlib.h>
#define InitSize 100   //初始化表长度
#define OVERFLOW -2
typedef int ElemType;  //元素类型，在此处可以快速更改元素类型，例如把int改为char型，则ElemType赋值的就为char型了
typedef struct{
    ElemType *data;    //指示动态分配数组的指针
    int MaxSize,length;//数组的最大容量 长度（当前个数）
} SqList;              //动态分配数组顺序表的类型定义


int InitList(SqList *L){
    L->data = (ElemType *)malloc(InitSize*sizeof(ElemType));  //动态分配语句
    if(!L->data) exit(OVERFLOW);
    L->length = 0;                                           //初始化为空表
    L->MaxSize = InitSize;                                   //初始化表的容量
    return 1;
}


void CreatList(SqList *L,ElemType e){                        //创建一个具有元素的表，其实就是不断的向表尾插入元素
    if(L->length >= L->MaxSize)
        printf("当前存储空间已满\n");
    L->data[L->length] = e;
    L->length++;
    return ;
}


int Length(SqList *L){
    return L->length;                                        //获取顺序表的长度
}


int LocateElem(SqList *L,ElemType e){                        //按值查找，查找具有指定关键字的元素
    int i;
    for(i = 0;i<L->length;i++)
    {
        if(L->data[i] == e)
        {
            printf("找到，%d在第%d个位置\n",e,i+1);
            return 0;                                        //for循环查找e的位置，若找到则立即返回
        }
    }
    printf("未查找到此元素。");
    return 0;
}


int GetElem(SqList *L,int i){                                //通过位置查找元素，并输出元素的值
    if(i<0 || i>L->length)
    {
        printf("此位置不在表中。\n");
    }
    else
    {
        i = L->data[i-1];
        printf("找到，此位置元素为%d \n",i);
    }
}


int ListInsert(SqList *L,int i,ElemType e){                  //指定位置插入元素e
    if(i<1 || i>L->length+1)
        printf("此位置不存在\n");                            //插入前须做两个判断
    if(L->length >= L->MaxSize)
        printf("当前存储空间已满\n");
    for(int j = L->length;j >= i;j--)
        L->data[j]=L->data[j-1];
    L->data[i-1] = e;
    L->length++;
    return 1;
}


int ListDelete(SqList *L,int i){                             //指定位置删除元素，并返回e值，此处主函数并未获取其值
    if(i<1 || i>L->length)
        printf("此位置不存在\n");
    ElemType e = L->data[i-1];
    for(int j=i;j<L->length;j++)
        L->data[j-1] = L->data[j];                           //被删除后的元素位置依次向前递增
    L->length--;
    return e;
}


void PrintList(SqList *L){                                   //打印表
    int i;
    for(i = 0;i < L->length;i++)
    {
        printf("%d",L->data[i]);
    }
    printf("\n");
    return ;
}


int Empty(SqList *L){
    return L->length == 0;
}


//void DestroyList(SqList L){
//  free(L);
//}


int main(){
    SqList list;
    InitList(&list);
    int length;
    printf("请输入初始表的长度：");
    scanf("%d",&length);
    int i;
    ElemType temp;
    printf("请依次输入表中元素：");
    for(i = 0;i < length;i++)
    {
        scanf("%d",&temp);
        CreatList(&list,temp);
    }
    printf("已创建好线性表：");
    PrintList(&list);
    int pos;
    printf("请输入需要插入的位置及元素：");
    scanf("%d %d",&pos,&temp);
    ListInsert(&list,pos,temp);
    printf("插入一个元素后的线性表:");
    PrintList(&list);
    printf("请输入需要删除元素的位置：");
    scanf("%d",&pos);
    ListDelete(&list,pos);
    printf("删除一个元素后的线性表：");
    PrintList(&list);
    printf("请输入需要查找的元素：");
    scanf("%d",&temp);
    LocateElem(&list,temp);
    printf("请输入需要查找元素的位置：");
    scanf("%d",&i);
    GetElem(&list,i);
    //DestroyList(list);
}

线性表的顺序存储类型描述为

#define MaxSize 100   //定义线性表最大长度
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];    //顺序表的元素
    int length;//数组的长度（当前个数）
} SqList;              //顺序表的类型定义

一维数组可以是静态分配的也可以是动态分配的。在静态分配时，由于数组的大小和空间事先已固定，一旦空间占满，再加入新的数据将会产生溢出，导致程序崩溃；而动态分配时，存储数组的空间是在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，可以另外开辟一块更大的空间。

#define InitSize 100   //初始化表长度
typedef int ElemType;  //元素类型，在此处可以快速更改元素类型，例如把int改为char型，则ElemType赋值的就为char型了
typedef struct{
    ElemType *data;    //指示动态分配数组的指针
    int MaxSize,length;//数组的最大容量 长度（当前个数）
} SqList;              //动态分配数组顺序表的类型定义

C的初始动态分配语句为

L->data = (ElemType*)malloc(sizeof(ElemType)*InitSize);

C++的初始动态分配语句为

L->data = new ElemType[InitSize];

空间不够时重新分配空间：

void Malloc(SqList *L)//空间不够时重新分配空间的函数  
{  
    ElemType *newbase;//分配一个临时基址  
    newbase=(ElemType *)realloc(L->data,(L->MaxSize+AddSize)*sizeof(ElemType));  
    if(!newbase) exit(OVERFLOW);  
    L->data=newbase;  
    L->MaxSize+=AddSize;  
}

AddSize 是提前定义的值，是存储空间的分配增量；此处程序未加入此函数，如要使用此函数，可在此程序中输出“当前存储空间已满”处调用此函数。