顺序表的相关操作（多文件编译）

seqlist.h

#ifndef __SQLIST_H__
#define __SQLIST_H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAXSIZE 10  //线性表长度
typedef int datatype;
//顺序表结构体：只能两个元素
//只要多一个成员，那么就不是顺序表
typedef struct{
    //数据元素：整数
    datatype data[MAXSIZE];
    //顺序表长度
    int len;
}seqlist;

seqlist *Creat();
int full_seqlist(seqlist *L);
void Insert_rear(seqlist *L,datatype e);
int empty_seqlist(seqlist *L);
void Output_seqlist(seqlist *L);
int delete_rear(seqlist *L);
int search_seqlist(seqlist *L,int index);
int Updata(seqlist *L,int index,datatype e);
int Insert_index(seqlist *L,int index,int e);
int delete_index(seqlist *L,int index);
int search_elem(seqlist *L,int elem);
int delete_elem(seqlist *L,datatype elem);
int Updata_elem(seqlist *L,datatype elem,datatype key);
int sort_seqlist(seqlist *L);


#endif

main.c

#include "seqlist.h"

int main(int argc,const char *argv[])
{
    seqlist *L=Creat();

    int index=0;
    //在顺序表尾部插入
    int n;
    datatype e;
    printf("请输入要输入的个数：");
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        printf("请输入值：");
        scanf("%d",&e);
        Insert_rear(L,e);
    }

    //输出
    Output_seqlist(L);

    //删除顺序表的内容
    delete_rear(L);
    delete_rear(L);
    Output_seqlist(L);
    
    //依据下标查找
    
    printf("请输入要查找的下标：");
    scanf("%d",&index);
    search_seqlist(L,index);

    //依据下标删除
    printf("请输入要修改的下标：");
    scanf("%d",&index);
    printf("请输入要修改的值：");
    scanf("%d",&e);
    Updata(L,index,e);
    Output_seqlist(L);

    //在指定下标插入
    printf("请输入要插入的下标：");
    scanf("%d",&index);
    printf("请输入要插入的值：");
    scanf("%d",&e);
    Insert_index(L,index,e);
    Output_seqlist(L);

    //删除指定下标对应的值
    printf("请输入要删除的值的下标：");
    scanf("%d",&index);
    delete_index(L,index);
    Output_seqlist(L);

    //按元素查找
    datatype elem=0;
    printf("请输入要查找的元素：");
    scanf("%d",&elem);
    index=search_elem(L,elem);
    printf("该元素的第一个下标：%d\n",index);
    
    //按元素删除
    printf("请输入要删除的元素：");
    scanf("%d",&elem);
    delete_elem(L,elem);
    Output_seqlist(L);

    //按元素修改
    datatype key;
    printf("请输入被修改的元素：");
    scanf("%d",&elem);
    printf("修改成的元素：");
    scanf("%d",&key);
    Updata_elem(L,elem,key);
    Output_seqlist(L);

    //顺序表排序（升序）
    sort_seqlist(L);
    Output_seqlist(L);

    //释放表空间
    free(L);
    L=NULL;
    return 0;
}

seqlist.c

#include"seqlist.h"

/*
 *function :  在堆区申请循序表空间
 *@param [in]:  无参数
 *@param [out]:
 *@return :  返回顺序表首地址
 */
seqlist *Creat(){
    seqlist *list=(seqlist *)malloc(sizeof(seqlist));
    if(NULL==list)
        return NULL;
    list->len=0;
    return list;
}

/*
 *function :  判断顺序表是否已满
 *@param [in]:  顺序表
 *@param [out]:
 *@return :  不满返回0，表满返回-1
 */
int full_seqlist(seqlist *L){
    return L->len==MAXSIZE?-1:0;
}

/*
 *function :  在顺序表尾部插入数值
 *@param [in]:  顺序表在堆区的首地址，要插入的元素
 *@param [out]:
 *@return :  无返回值
 */
void Insert_rear(seqlist *L,datatype e){
    //判满
    if(full_seqlist(L)){
        printf("尾插失败\n");
        return;
    }
    //不满继续进行
    L->data[L->len]=e;
    L->len++;
}

/*
 *function :  判断顺序表是否为空
 *@param [in]:  顺序表
 *@param [out]:
 *@return :  表空为-1，不空为0
 */
int empty_seqlist(seqlist *L){
    return L->len==0?-1:0;
}

/*
 *function :  输出顺序表的内容
 *@param [in]:  顺序表
 *@param [out]:
 *@return :  无返回值
 */
void Output_seqlist(seqlist *L){
    for(int i=0;i<L->len;i++){
        printf("%d\t",L->data[i]);
    }
    printf("\n");
}

/*
 *function :  从尾部删除顺序表的内容
 *@param [in]:  顺序表
 *@param [out]:
 *@return :  成功为0；失败为-1
 */
int delete_rear(seqlist *L){
    if(empty_seqlist(L)){
        printf("尾部删除失败\n");
        return -1;
    }
    L->len--;
    return 0;
}

/*
 *function :  依据下标查找
 *@param [in]:  顺序表，下标
 *@param [out]:
 *@return :  成功返回0；失败返回-1
 */
int search_seqlist(seqlist *L,int index){
    //判空，下标的合法性
    if(empty_seqlist(L)||index>=L->len||index<0){
        printf("依据下标查找失败\n");
        return -1;
    }
    printf("依据下标查找成功，查找的下标的值为：%d\n",L->data[index]);
    return 0;
}

/*
 *function :  依据下标修改顺序表的值
 *@param [in]:  顺序表，下标，修改的值
 *@param [out]:
 *@return :  成功返回0；失败返回-1
 */
int Updata(seqlist *L,int index,datatype e){
    //判空，下标的合法性
    if(empty_seqlist(L)||index>=L->len||index<0){
        printf("依据下标删除失败\n");
        return -1;
    }
    L->data[index]=e;
    return 0;

}

/*
 *function :  在顺序表中依据下标进行插入
 *@param [in]:  顺序表，下标，插入的值
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Insert_index(seqlist *L,int index,int e){
    //判满，下标的合法性
    if(full_seqlist(L)||index<0||index>L->len){
        printf("依据下标插入失败\n");
        return -1;
    }
    for(int i=L->len-1;i>=index;i--){
        L->data[L->len]=L->data[L->len-1];
    }
    L->data[index]=e;
    L->len++;
    return 0;
}

/*
 *function :  删除指定下标对应的值
 *@param [in]:  顺序表，下标
 *@param [out]:
 *@return :  成功返回0；失败返回-1
 */
int delete_index(seqlist *L,int index){
    //判空，下标的合法性
    if(empty_seqlist(L)||index<0||index>=L->len){
        printf("依据下标删除失败\n");
        return -1;
    }
    for(int i=index;i<L->len-1;i++){
        L->data[i]=L->data[i+1];
    }
    L->len--;
    return 0;
}

/*
 *function :  按元素查找
 *@param [in]:  顺序表，要查找的元素
 *@param [out]:
 *@return :  该元素的下标
 */
int search_elem(seqlist *L,datatype elem){
    if(empty_seqlist(L)){
        printf("顺序表为空\n");
        return -1;
    }
    for(int i=0;i<L->len;i++){
        if(L->data[i]==elem){
            return i;
        }        
    }
    printf("该表没有该元素\n");
    return -1;
}

/*
 *function :  按元素删除
 *@param [in]:  顺序表，元素
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int delete_elem(seqlist *L,datatype elem){
    int index=search_elem(L,elem);
    if(index==-1){
        printf("没有该元素\n");
        return -1;
    }
    if(delete_index(L,index)){
        printf("删除失败\n");
        return -1;
    }
    return 0;
}

/*
 *function :  按元素修改
 *@param [in]:  顺序表，被修改的元素，修改后的元素
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int Updata_elem(seqlist *L,datatype elem,datatype key){
    int index=search_elem(L,elem);
    if(index==-1){
        printf("没有该元素\n");
        return -1;
    }
    L->data[index]=key;
    return 0;
}

/*
 *function :  顺序表排序(升序)
 *@param [in]:  顺序表
 *@param [out]:
 *@return :  成功返回0，失败返回-1
 */
int sort_seqlist(seqlist *L){
    if(empty_seqlist(L)||L->len==1)
        return -1;
    for(int i=1;i<L->len;i++){
        int count=0;
        for(int j=0;j<L->len-i;j++){
            if(L->data[j]>L->data[j+1]){
                datatype temp=L->data[j];
                L->data[j]=L->data[j+1];
                L->data[j+1]=temp;
                count++;
            }
        }
        if(count==0)
            break;
    }
    return 0;
}