一、概念

线性表的顺序存储指的是用一组地址连续的存储单元依次存储线性表的数据结构。

——《数据结构》C语言版

简而言之，也就是编程语言中常见的数组Array。

图1-1

二、代码

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

//宏定义结构体
typedef struct Array{
    int * pbase; //首地址
    int len; //总长度
    int cnt; //当前长度
}ARRAY;

//数组初始化
void arr_init(ARRAY * pArr, int length){
    //动态分配内存
    pArr->pbase = (int *)malloc(sizeof(int)*length);
    //是否分配成功
    if(pArr->pbase == NULL){
        printf("内存分配失败\n");
        exit(-1);
    }
    //初始化长度
    pArr->len = length;
    pArr->cnt = 0;
}

//数组是否为空
bool arr_isEmpty(ARRAY * pArr){
    //true是，false不是
    if(pArr->cnt == 0)
        return true;
    else
        return false;
}

//数组遍历
void arr_show(ARRAY * pArr){
    //数组是否为空
    if(arr_isEmpty(pArr) == true)
        printf("数组为空\n");
    else{
        //不为空，则遍历数组
        for(int i=0; i<pArr->cnt; i++){
            printf("%d\n", pArr->pbase[i]);
        }
    }
}

//数组追加
bool arr_append(ARRAY * pArr, int value){
    //数组是否满员
    if(pArr->cnt < pArr->len){
        //没满，则追加一个数据
        pArr->pbase[pArr->cnt] = value;
        pArr->cnt++;
        return true;
    }
    else
        //满了，则放弃该操作
        return false;
}

//数组删除
bool arr_delete(ARRAY * pArr, int index){
    //判断索引
    if(index < 1 || index > pArr->cnt){
        printf("没有序号小于1或大于%d的数据\n", pArr->cnt);
        return false;
    }
    else{
        //对应数据存在，则删除
        for(int i=index; i<pArr->cnt; i++){
            pArr->pbase[i-1] = pArr->pbase[i];
        }
        pArr->cnt--;
        return true;
    }
}

//数组修改
bool arr_alter(ARRAY * pArr, int index, int value){
    //判断索引
    if(index < 1 || index > pArr->cnt){
        printf("没有序号小于1或大于%d的数据\n", pArr->cnt);
        return false;
    }
    else{
        //对应数据存在，则修改
        pArr->pbase[index] = value;
        return true;
    }
}

//数组查找
bool arr_find(ARRAY * pArr, int value){
    //判断要查找的值
    for(int i=0; i<pArr->cnt; i++){
        if(pArr->pbase[i] == value){
            printf("找到了%d\n", value);
            return true;
        }
    }
    printf("没找到%d\n", value);
    return false;
    
}

//数组排序
void arr_sort(ARRAY * pArr){
    //冒泡排序（升序），最多(cnt-1)!次
    //注意：i=1，因为最后一个数据的索引是cnt-1
    for(int i=1; i<pArr->cnt; i++){
        for(int j=0; j<pArr->cnt-i; j++){
            if(pArr->pbase[j] > pArr->pbase[j+1]){
                //临时变量，用于置换
                int temp = pArr->pbase[j];
                pArr->pbase[j] = pArr->pbase[j+1];
                pArr->pbase[j+1] = temp;
            }
        }
    }
}

//数组逆序
void arr_invert(ARRAY * pArr){
    //反转每一个元素
    //注意：i < cnt/2，因为最多cnt/2次
    for(int i=0; i < pArr->cnt/2; i++){
        //临时变量，用于置换
        int temp = pArr->pbase[i];
        //因为一开始i=0，所以cnt-1-i
        pArr->pbase[i] = pArr->pbase[pArr->cnt-1-i];
        pArr->pbase[pArr->cnt-i-1] = temp;
    }
}

//主函数
int main(void){
    ARRAY arr;//声明数组
    //调用API
    arr_init(&arr,5);
    arr_append(&arr,5);
    arr_append(&arr,4);
    arr_append(&arr,3);
    arr_append(&arr,2);
    arr_append(&arr,1);
    //arr_delete(&arr,2);
    //arr_alter(&arr,1,10);
    arr_sort(&arr);
    arr_invert(&arr);
    arr_show(&arr);
    //arr_find(&arr,4);

    return 0;
}