数组实现的线性表基本操作[C]

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

struct Arr {
    int *pBase;     // 存储的是数组第一个元素的地址
    int len;        // 数组所能容纳的最大元素个数
    int cnt;        // 当前数组有效元素个数
};

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);
bool get_arr(struct Arr *pArr, int pos, int *pVal);
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 reverse_arr(struct Arr *pArr);

int main() {
    struct Arr arr;

    init_arr(&arr, 6); // 初始化数组线性表，设置表中最大元素是6个
    printf("%d\n", arr.len);
    show_arr(&arr);

    append_arr(&arr, 1);
    append_arr(&arr, 2);
    append_arr(&arr, 3);
    append_arr(&arr, 4);
//    append_arr(&arr, 5);
//    append_arr(&arr, 6);
//    if (append_arr(&arr, 6)) {
//        printf("追加成功了\n");
//    } else {
//        printf("数组线性表已经满了，追加失败\n");
//        printf("线性表中的数据依次是：");
//        show_arr(&arr);
//    }

    insert_arr(&arr, 1, 99);
    show_arr(&arr);

    int val; // 删除的值或者查找的值
    if (delete_arr(&arr, 1, &val)) {
        printf("删除成功了\n");
        printf("删除的元素是%d\n", val);
    }

    if (get_arr(&arr, 1, &val)) {
        printf("get value is %d\n", val);
    }

    printf("翻转数组线性表前：\n");
    show_arr(&arr);
    reverse_arr(&arr);
    printf("翻转数组线性表后：\n");
    show_arr(&arr);

    printf("sort: \n");
    sort_arr(&arr);
    show_arr(&arr);

    return 0;
}

/**
 * 初始化
 *
 * @param pArr
 * @param length
 */
void init_arr(struct Arr *pArr, int length) {
    pArr->pBase = (int *) malloc(sizeof(int) * length);
    // 必须判断是否分配成功，否则直接使用可能导致空指针错误
    if (NULL == pArr->pBase) {
        printf("动态内存分配失败!");
        exit(-1);
    } else {
        pArr->len = length;
        pArr->cnt = 0;
    }

    return;
}

/**
 * 数组线性表是否为空
 *
 * @param pArr
 * @return
 */
bool is_empty(struct Arr *pArr) {

    return pArr->cnt == 0;
}

/**
 * 打印数组线性表
 *
 * @param pArr
 */
void show_arr(struct Arr *pArr) {
    if (is_empty(pArr)) {
        printf("数组为空!\n");
    } else {
        for (int i = 0; i < pArr->cnt; ++i) {
            printf("%d ", pArr->pBase[i]);
        }
        printf("\n");
    }
}

/**
 * 数组线性表是否满了
 *
 * @param pArr
 * @return
 */
bool is_full(struct Arr *pArr) {
    return pArr->cnt == pArr->len;
}

/**
 * 向数组线性表中插入数据
 *
 * @param pArr
 * @param val
 * @return
 */
bool append_arr(struct Arr *pArr, int val) {
    if (is_full(pArr)) {
        return false;
    } else {
        pArr->pBase[pArr->cnt] = val;
        pArr->cnt++;
    }
}

/**
 * 向数组线性表中插入数据
 *
 * @param pArr
 * @param pos
 * @param val
 * @return
 */
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;
    }

    // 先移动元素
    for (int i = pArr->cnt - 1; i >= pos - 1; i--) {
        pArr->pBase[i + 1] = pArr->pBase[i];
    }
    // 插入元素
    pArr->pBase[pos - 1] = val;
    pArr->cnt++;

    return true;
}

/**
 * 删除数组线性表中的数据
 *
 * @param pArr
 * @param pos
 * @param pVal
 * @return
 */
bool delete_arr(struct Arr *pArr, int pos, int *pVal) {
    if (is_empty(pArr)) {
        return false;
    }
    if (pos < 1 || pos > pArr->cnt) {
        return false;
    }

    *pVal = pArr->pBase[pos - 1]; // 删除的值存入变量中

    // 向前移动元素
    for (int i = pos; i < pArr->cnt; ++i) {
        pArr->pBase[i - 1] = pArr->pBase[i];
    }
    pArr->cnt--;

    return true;
}

/**
 * 获取数组线性表中第pos个元素的值
 *
 * @param pArr
 * @param pos
 * @param pVal
 * @return
 */
bool get_arr(struct Arr *pArr, int pos, int *pVal) {
    if (pos > pArr->cnt) {
        return false;
    } else {
        *pVal = pArr->pBase[pos - 1];
        return true;
    }
}

/**
 * 翻转数组线性表中的数据
 *
 * @param pArr
 */
void reverse_arr(struct Arr *pArr) {
    int i = 0;
    int j = pArr->cnt - 1;
    int t;

    while (i < j) {
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }

    return;
}

/**
 * 对数组线性表排序
 *
 * @param pArr
 */
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;
            }
        }
    }

    return;
}