【C语言】 “函数指针”和“指针函数” 用法和详解（太细了！！！）菜鸟级教程

---

一、前言

数据结构是计算机科学中的基本概念之一，它有助于组织和管理数据。在编程中，选择适当的数据结构对于解决问题至关重要。静态顺序表和动态顺序表都是用于存储一系列元素的数据结构，但它们在容量管理和灵活性方面有所不同。

---

二、静态顺序表

2.1 什么是静态顺序表

静态顺序表是一个固定大小的数组，其容量在创建时被确定，不能动态改变。它适用于小规模数据集，因为其大小在编译时被确定。

2.2 静态顺序表的特点

（1）固定容量
（2）随机访问
（3）顺序存储
（4）适用于不会改变大小的数据集

2.3 静态顺序表的使用

代码如下（示例）：

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

#define MAX_SIZE 10

// 静态顺序表的结构体定义
typedef struct {
    int data[MAX_SIZE]; // 数据存储数组
    int length;         // 当前元素个数
} StaticArrayList;

// 初始化静态顺序表
void initStaticArrayList(StaticArrayList *list) {
    list->length = 0; // 初始时，元素个数为0
}

// 插入元素到静态顺序表
int insertElement(StaticArrayList *list, int value) {
    if (list->length < MAX_SIZE) { // 如果静态顺序表未满
        list->data[list->length] = value; // 将元素插入到数组中
        list->length++; // 更新元素个数
        return 1; // 插入成功
    } else {
        return 0; // 顺序表已满，插入失败
    }
}

// 释放静态顺序表内存
void freeStaticArrayList(StaticArrayList *list) {
    list->length = 0; // 重置元素个数为0，表示清空静态顺序表
}

int main() {
    StaticArrayList myList; // 创建静态顺序表实例
    initStaticArrayList(&myList); // 初始化静态顺序表

    // 插入元素，并检查是否插入成功
    if (insertElement(&myList, 10) && insertElement(&myList, 20) && insertElement(&myList, 30)) {
        // 遍历静态顺序表并打印元素
        for (int i = 0; i < myList.length; i++) {
            printf("%d ", myList.data[i]);
        }
    } else {
        fprintf(stderr, "插入失败\n"); // 插入失败时打印错误消息
    }

    freeStaticArrayList(&myList); // 释放静态顺序表内存

    return 0;
}

输出结果 ： 10 20 30

三、动态顺序表

3.1 什么是动态顺序表

动态顺序表是一个可以动态扩展和收缩的数组，其大小可以在运行时动态调整。它适用于需要频繁插入或删除元素的情况。

3.2 动态顺序表的特点

（1）动态扩展和收缩
（2）随机访问
（3）顺序存储
（4）适用于动态变化的数据集

3.3 动态顺序表的使用

代码如下（示例）：

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

#define INITIAL_CAPACITY 10

// 动态顺序表的结构体定义
typedef struct {
    int *data;     // 用于存储数据的数组
    int length;    // 当前元素个数
    int capacity;  // 当前容量
} DynamicArrayList;

// 初始化动态顺序表
void initDynamicArrayList(DynamicArrayList *list) {
    list->data = (int *)malloc(INITIAL_CAPACITY * sizeof(int)); // 分配初始容量的内存
    if (list->data == NULL) {
        fprintf(stderr, "内存分配失败\n");
        exit(1);
    }
    list->length = 0;        // 初始时，元素个数为0
    list->capacity = INITIAL_CAPACITY;  // 初始容量
}

// 插入元素到动态顺序表
int insertElement(DynamicArrayList *list, int value) {
    if (list->length == list->capacity) {
        int newCapacity = list->capacity * 2; // 扩大容量为当前容量的两倍
        int *newData = (int *)malloc(newCapacity * sizeof(int));

        if (newData == NULL) {
            return 0; // 内存分配失败
        }

        for (int i = 0; i < list->length; i++) {
            newData[i] = list->data[i]; // 复制元素到新数组
        }

        free(list->data); // 释放旧数组的内存
        list->data = newData; // 使用新数组
        list->capacity = newCapacity; // 更新容量
    }

    list->data[list->length] = value; // 插入元素到数组
    list->length++; // 更新元素个数
    return 1; // 插入成功
}

// 释放动态顺序表内存
void freeDynamicArrayList(DynamicArrayList *list) {
    free(list->data); // 释放数组内存
    list->length = 0; // 重置元素个数为0
    list->capacity = 0; // 重置容量为0
}

int main() {
    DynamicArrayList myList;
    initDynamicArrayList(&myList); // 初始化动态顺序表

    // 插入元素，并检查是否插入成功
    if (insertElement(&myList, 10) && insertElement(&myList, 20) && insertElement(&myList, 30)) {
        // 遍历动态顺序表并打印元素
        for (int i = 0; i < myList.length; i++) {
            printf("%d ", myList.data[i]);
        }
    } else {
        fprintf(stderr, "插入失败\n"); // 插入失败时打印错误消息
    }

    freeDynamicArrayList(&myList); // 释放动态顺序表内存

    return 0;
}

输出结果 ： 10 20 30

四、优缺点

4.1 优缺点图示

特点	静态顺序表	动态顺序表
内存管理	简单，不需要动态内存分配和释放	复杂，需要动态内存分配和释放
容量固定	是，不允许动态改变	否，允许动态扩展和缩小容量
随机访问效率	高，O(1)	高，O(1)
适用于动态数据集	否，不适合动态变化的数据集	是，适用于动态变化的数据集
空间利用率	高，无额外空间开销	可能较低，由于动态扩展和缩小的额外开销
编码复杂度	低，较为简单	高，需要处理内存分配失败和数据复制

五、区别图示

总结

选择静态顺序表还是动态顺序表取决于你的应用需求。如果数据集大小是已知的且不会改变，静态顺序表是一个简单而高效的选择。如果数据集大小未知或需要频繁改变，动态顺序表提供了更大的灵活性，但需要更复杂的内存管理。

---

粉丝福利、需求解答