线性结构——连续存储：数组_c语言数组连续存储-CSDN博客

本文链接：https://blog.csdn.net/dream_aleaf/article/details/129506470

正在学习郝斌老师讲解的数据结构，课程内容真的讲解得十分细致，对线性结构中的连续存储——数组的学习内容用C语言进行了实现，如有错误之处，欢迎指出来哦！
对数组进行操作，首先初始化数组，然后遍历数组，接着往数组中追加元素，指定位置插入元素（在指定位置之前插入元素，位置从1开始计算），删除指定位置的元素，对数组元素进行倒置，排序，取指定位置的数组元素。
代码如下

#include <stdio.h>
#include <stdbool.h>
#include <malloc.h>
#include <stdlib.h>
struct Arr{
    int *pBase;
    int len;
    int cnt;};
void init_arr(struct Arr *pArr, int length);
bool is_empty(struct Arr *pArr);
void show_arr(struct Arr *pArr);
bool is_full(struct Arr *pArr);
bool append_arr(struct Arr *pArr, int val);
bool insert_arr(struct Arr *pArr, int pos, int val);
bool delete_arr(struct Arr *pArr, int pos, int *pval);
void inversion_arr(struct Arr *pArr);
void sort_arr(struct Arr *pArr);
bool get_arr(struct Arr *pArr, int pos, int *pval);
int main(){
    struct Arr arr;
    printf("1. 初始化数组\n");
    printf("请输入你需要的数组长度:length=");
    int length;
    scanf("%d", &length);
    init_arr(&arr, length);
    printf("2. 遍历数组元素\n");
    show_arr(&arr);
    printf("3. 向数组里追加元素\n");
    while (1){
        printf("请输入追加的数组元素:value=");
        int value;
        scanf("%d", &value);
        if (append_arr(&arr, value))
            printf("追加元素操作成功执行!\n");
        else{
            printf("追加元素操作失败!\n");
            break;}}
    printf("遍历数组元素:");
    show_arr(&arr);
    printf("4. 在数组指定位置之前插入元素\n");
    printf("请输入你要插入元素的位置:pos=");
    int pos;
    scanf("%d", &pos);
    printf("请输入你要插入的数组元素:value=");
    int value;
    scanf("%d", &value);
    if (insert_arr(&arr, pos, value)){
            printf("插入元素操作成功执行!\n遍历数组元素:");
            show_arr(&arr);}
    else
        printf("插入元素操作失败!\n");
    printf("5. 删除数组指定位置元素\n");
    printf("请输入你要删除元素的位置:pos=");
    scanf("%d", &pos);
    if (delete_arr(&arr, pos, &value)){
            printf("删除元素操作成功执行!\n你删除的元素:value=%d\n遍历数组元素:", value);
            show_arr(&arr);}
    else
        printf("删除元素操作失败!\n");
    printf("6. 倒置数组元素\n");
    inversion_arr(&arr);
    printf("遍历数组元素:");
    show_arr(&arr);
    printf("7. 对数组元素进行升序排序\n");
    sort_arr(&arr);
    printf("遍历数组元素:");
    show_arr(&arr);
    printf("8. 输出数组指定位置的元素\n");
    printf("请输入你要查找元素的位置:pos=");
    scanf("%d", &pos);
    if (get_arr(&arr, pos, &value))
        printf("对应的元素:vlaue=%d", value);
    else
        printf("元素不存在！");
    return 0;}
void init_arr(struct Arr *pArr, int length){
    pArr->pBase = (int*)malloc(sizeof(int)*length);
    if (NULL == pArr->pBase){
        printf("动态内存分配失败!\n");
        exit(-1);}
    else{
        pArr->len = length;
        pArr->cnt = 0;
        printf("数组初始化成功!\n");}
    return;}
bool is_empty(struct Arr *pArr){
    if (pArr->cnt == 0)
        return true;
    else
        return false;}
void show_arr(struct Arr *pArr){
    if (is_empty(pArr))
        printf("这是一个空数组!\n");
    else{
        int i = 0;
        for (i=0; i<pArr->cnt; i++)
            printf("%d ", pArr->pBase[i]);
        printf("\n");}}
bool is_full(struct Arr *pArr){
    if (pArr->cnt == pArr->len)
        return true;
    else
        return false;}
bool append_arr(struct Arr *pArr, int val){
    if (is_full(pArr))
        return false;
    else{
        pArr->pBase[pArr->cnt] = val;
        pArr->cnt++;
        return true;}}
bool insert_arr(struct Arr *pArr, int pos, int val){
    if (is_full(pArr) || pos<1 || pos>pArr->cnt)
        return false;
    else{
        int i = 0;
        for (i=pArr->cnt-1; i>=pos-1; i--)
            pArr->pBase[i+1] = pArr->pBase[i];
        pArr->pBase[pos-1] = val;
        pArr->cnt++;
        return true;}}
bool delete_arr(struct Arr *pArr, int pos, int *pval){
    if (is_empty(pArr) || pos<1 || pos>pArr->cnt)
        return false;
    else{
        *pval = pArr->pBase[pos-1];
        int i = 0;
        for (i=pos; i<pArr->cnt; i++)
            pArr->pBase[i-1] = pArr->pBase[i];
        pArr->cnt--;
        return true;}}
void inversion_arr(struct Arr *pArr){
    int i, j, t;
    for (i=0,j=pArr->cnt-1; i<j; i++,j--){
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;}}
void sort_arr(struct Arr *pArr){
    int i, j, t;
    for (i=0; i<pArr->cnt; i++){
        for (j=i+1; j<pArr->cnt; j++){
            if (pArr->pBase[i] > pArr->pBase[j]){
                t = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;}}}}
bool get_arr(struct Arr *pArr, int pos, int *pval){
    if (pos<1 || pos>pArr->cnt)
        return false;
    else{
        *pval = pArr->pBase[pos-1];
        return true;}}

运行结果

/*线性结构【把所有的结点用一根直线穿起来】
连续存储【数组】
    1. 什么叫数组
    元素类型相同，大小相等 

离散存储【链表】 */

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

//定义了一个数据类型，该数据类型的名字叫做struct Arr， 该数据类型含有三个成员，分别是pBase、len、cnt 
struct Arr{
    int * pBase; //存储的是数组第一个元素的地址 
    int len; //数组所能容纳的最大元素的个数
    int cnt; //当前数组有效元素的个数 
//    int increment; //自动增长因子 
};

void init_arr(struct Arr * pArr, int length);
bool append_arr(struct Arr * pArr, int val); //追加 
bool insert_arr(struct Arr * pArr, int pos, int val); //pos的值从1开始 
bool delete_arr(struct Arr * pArr, int pos, int * pval);
int get();
bool is_empty(struct Arr * pArr);
bool is_full(struct Arr * pArr);
void sort_arr(struct Arr * pArr);
void show_arr(struct Arr * pArr);
void inversion_arr(struct Arr * pArr);

int main(){
    struct Arr arr;
    int val;

    init_arr(&arr, 6);
    show_arr(&arr);
    append_arr(&arr, 1);
    append_arr(&arr, 10);
    append_arr(&arr, -3);
    append_arr(&arr, 6);
    append_arr(&arr, 88);
    append_arr(&arr, 11);
    if (delete_arr(&arr, 4, &val)){
        printf("删除成功！\n");
        printf("您删除的元素是：%d\n", val);
    }
    else {
        printf("删除失败！\n");
    }

    /*append_arr(&arr, 2);
    append_arr(&arr, 3);
    append_arr(&arr, 4);
    append_arr(&arr, 5);
    insert_arr(&arr, 0, 99);*/
    /*append_arr(&arr, 6);
    append_arr(&arr, 7);
    if (append_arr(&arr, 8)){
        printf("追加成功！\n");
    }
    else {
        printf("追加失败！\n");
    }*/
    show_arr(&arr);
    inversion_arr(&arr);
    printf("倒置之后的数组内容是：\n");
    show_arr(&arr);
    sort_arr(&arr);
    show_arr(&arr);
//    printf("%d\n", arr.len);

    return 0;
}

void init_arr(struct Arr *pArr, int length){
    pArr->pBase = (int *)malloc(sizeof(int) * length);
    if (NULL == pArr->pBase){
        printf("动态内存分配失败！\n");
        exit(-1); //终止整个程序 
    }
    else {
        pArr->len = length;
        pArr->cnt = 0;
    } 
    return;
}

bool is_empty(struct Arr * pArr){
    if (pArr->cnt == 0){
        return true;
    }
    else {
        return false;
    }
}

void show_arr(struct Arr * pArr){
    if (is_empty(pArr)){
        printf("数组为空！\n");
    }
    else {
        int i;
        for (i=0; i<pArr->cnt; i++){
            printf("%d ", pArr->pBase[i]);
        }
        printf("\n");
    }
    return;
}

bool is_full(struct Arr * pArr){
    if (pArr->cnt == pArr->len){
        return true;
    }
    else {
        return false;
    }
}

bool append_arr(struct Arr * pArr, int val){
    //满时返回false 
    if (is_full(pArr)){
        return false;
    }

    //不满时追加 
    pArr->pBase[pArr->cnt] = val;
    (pArr->cnt)++;
    return true;
}

bool insert_arr(struct Arr * pArr, int pos, int val){
    if (is_full(pArr)){
        return false;
    }
    if (pos<1 || pos>pArr->cnt+1){
        return false;
    }
    int i;
    for (i=pArr->cnt-1; i>=pos-1; i--){
        pArr->pBase[i+1] = pArr->pBase[i];
    }
//    for (i=pArr->cnt; i>=pos; i--){
//        pArr->pBase[i] = pArr->pBase[i-1]; 
//    }
    pArr->pBase[pos-1] = val;
    pArr->cnt++;
    return true;
}

bool delete_arr(struct Arr * pArr, int pos, int * pval){
    if (is_empty(pArr)){
        return false;
    }   
    if (pos<1 || pos>pArr->cnt){
        return false;
    }
    int i;
    *pval = pArr->pBase[pos-1];
    for (i=pos; i<pArr->cnt; i++){
        pArr->pBase[i-1] = pArr->pBase[i];
    }
    pArr->cnt--;
    return true;
}

void inversion_arr(struct Arr * pArr){
    int i, j, tmp;

    for (i=0, j=pArr->cnt-1; i<j; i++, j--){
        tmp = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = tmp;
    }
    return;
}

void sort_arr(struct Arr * pArr){
    int i, j, tmp;

    for (i=0; i<pArr->cnt; i++){
        for (j=i+1; j<pArr->cnt; j++){
            if (pArr->pBase[i] > pArr->pBase[j]){
                tmp = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = tmp;
            }
        }
    }
    /*for (i=0; i<pArr->cnt-1; i++){
        for (j=0; j<pArr->cnt-1-i; j++){
            if (pArr->pBase[j] > pArr->pBase[j+1]){
                tmp = pArr->pBase[j];
                pArr->pBase[j] = pArr->pBase[j+1];
                pArr->pBase[j+1] = tmp;
            }
        }
    }*/
    return;
}