C语言实现线性表连续存储结构相关算法

使用C语言编写的线性表连续存储结构的各种算法，包括插入，删除，清空，判断是否已满等，以下为代码：

# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>  //包含了exit函数

struct Arr
{
    int * pBase;
    int len;
    int cnt;
};

//初始化
void init(struct Arr * p,int length);
//附加新元素
bool append(struct Arr * p,int val);
//添加新元素
bool insert(struct Arr * p,int pos,int val);
//删除一个元素
bool deleteArr(struct Arr * p,int pos);
//删除所有的元素
bool deleteAll(struct Arr * p);
//获取指定位置的元素
int get(struct Arr * p,int pos);

bool isEmpty(struct Arr * p);//判断是否为空
//判断是否已满
bool isFull(struct Arr * p);
//排序（升序）
bool sortAsc(struct Arr * p);
//反转
void reverse(struct Arr * P);
//显示数组
void show(struct Arr * p);

int main(int argc, char *argv[])
{
    //初始一个有10元素的数组
    struct Arr arr;
    init(&arr,10);
    //加入几个元素
    append(&arr,-80);
    append(&arr,-40);
    append(&arr,50);
    append(&arr,60);
    append(&arr,3);
    append(&arr,10);
    append(&arr,30);
    show(&arr);
    insert(&arr,1,-1);
    insert(&arr,11,8);
    insert(&arr,3,5);
    show(&arr);
    deleteArr(&arr,4);
    deleteArr(&arr,-8);
    show(&arr);
    sortAsc(&arr);
    printf("排序后输出如下：\n");
    show(&arr);
    reverse(&arr);
    show(&arr);
    return 0;
}

//初始化
void init(struct Arr * p,int length){
    p->pBase=(int *)malloc(sizeof(int) * length);
    if(p->pBase==NULL){
        printf("数组初始化失败!\n");
    }
    p->len=length;
    p->cnt=0;
}
//附加新元素
bool append(struct Arr *p,int val){
    if(isFull(p))
    {
        printf("数组已满，元素%d插入失败\n",val);
        return true;
    }
    p->pBase[p->cnt]=val;
    p->cnt=p->cnt+1;
    return false;
}
//添加新元素
bool insert(struct Arr * p,int pos,int val)
{
    if(isFull(p))
    {
        printf("数组已满，向第%d个位置插入元素%d失败\n",pos,val);
        return false;
    }
    if(pos<1||pos>p->cnt+1){
        printf("插入位置有误，向第%d个位置插入元素%d失败\n",pos,val);
        return false;
    }
    for(int i=p->cnt;i>pos-1;i--){
        p->pBase[i]=p->pBase[i-1];
    }
    p->pBase[pos-1]=val;
    p->cnt=p->cnt+1;
    return true;
}
//删除一个元素
bool deleteArr(struct Arr * p,int pos){
    if(isEmpty(p))
    {
        printf("数组已空，删除第%d个元素%d失败\n",pos);
        return false;
    }
    if(pos<1||pos>p->cnt){
        printf("删除位置有误，删除第%d个位置元素失败\n",pos);
        return false;
    }
    for(int i=pos;i<p->cnt;i++){
        p->pBase[i-1]=p->pBase[i];
    }
    p->cnt=p->cnt-1;
    return true;
}
//删除所有的元素
bool deleteAll(struct Arr * p){
    p->cnt=0;
}
//获取指定位置的元素
int get(struct Arr * p,int pos){
    if(pos<-1||pos>p->cnt){
        printf("获取第%d个元素失败，您输入的位置有误\n！",pos);
        return 0;
    }
    return p->pBase[pos-1];
}
//判断是否为空
bool isEmpty(struct Arr * p){
    if(p->cnt==0){
        return true;
    }
    return false;
}
//判断是否已满
bool isFull(struct Arr * p){
    if(p->cnt==p->len){
        return true;
    }
    return false;
}
//排序（升序）
bool sortAsc(struct Arr * p){
    int t=0,i=0,j=0;
    for(i=0;i<p->cnt;i++){
        for(j=i+1;j<p->cnt;j++){
            if(p->pBase[i]>p->pBase[j]){
                t=p->pBase[j];
                p->pBase[j]=p->pBase[i];
                p->pBase[i]=t;
            }
        }
    }
}
//反转
void reverse(struct Arr * p){
    if(isEmpty(p)){
        return ;
    }
    int i=0,t=0,j=0;
    j=p->cnt-1;
    while(i<j)
    {
        t=p->pBase[i];
        p->pBase[i]=p->pBase[j];
        p->pBase[j]=t;
        i++;
        j--;
    }
}

//显示数组
void show(struct Arr * p){
    if(isEmpty(p))
    {
        printf("数组为空");
    }
    int i=0;
    for(i=0;i<p->cnt;i++){
        printf("%d ",p->pBase[i]);
    }
    printf("\n");
}

线性表连续存储结构的算法中，插入与删除是最重要，需要重点掌握以下的两点：

　　1）插入或者删除的位置

　　2）元素移动的顺序