小白也爱看的数据结构（顺序表完结）-优快云博客

本文链接：https://blog.youkuaiyun.com/chenyuhao2024/article/details/146133403

时间紧，任务重。我们直接开始。我看了一下上一篇文章的具体的讲解，需要上下翻看很不容易，这篇文章，我就会以注释的形式写在代码里，必要的细节再给大家讲解。

当然相比于前面的代码，现在的一各个函数就是洒洒水啦

顺序表尾插

// 顺序表尾插函数：在顺序表末尾插入一个元素
void SeqListPushBack(SeqList* psl, SLDataType x) {
    assert(psl);  // 确保传入的顺序表指针非空
    CheckCapacity(psl);  // 检查容量，若当前容量不足，自动扩容
    
    // 插入元素到尾部：
    // 1. psl->size 表示当前最后一个有效数据的下一个位置
    // 2. 将 x 存入数组的 psl->size 索引处
    // 3. 完成插入后，size 自增 1，指向新的末尾位置
    psl->array[psl->size++] = x;
}

顺序表尾删

// 顺序表尾删
void SeqListPopBack(SeqList* psl) {
    // 断言检查，确保传入的顺序表指针非空
    assert(psl);
    
    // 检查当前顺序表是否为空
    if (psl->size == 0) {
        printf("顺序表已空，无法删除\n");
        return; // 提前返回，不执行删除操作
    }
    
    // 删除尾部只需将有效数据个数减1
    // 注：无需删除数据，后续插入操作会覆盖该位置
    psl->size--;
}

顺序表头插

int main() {
    SeqList list;
    SeqListInit(&list, 3);  // 初始化容量为 3

    // 头插元素 3, 2, 1
    SeqListPushFront(&list, 3);  // 容量足够，直接插入
    SeqListPushFront(&list, 2);  // 容量足够，插入后元素：2, 3
    SeqListPushFront(&list, 1);  // 容量足够，插入后元素：1, 2, 3

    // 继续头插元素 0（触发扩容）
    SeqListPushFront(&list, 0);  // 容量不足，扩容至 6，插入后元素：0, 1, 2, 3

    SeqListDestroy(&list);
    return 0;
}

顺序表头删

// 顺序表头删
void SeqListPopFront(SeqList* psl) {
    assert(psl);
    if (psl->size == 0) {
        printf("顺序表已空，无法删除\n");
        return;
    }
    // 所有元素前移
    for (size_t i = 0; i < psl->size - 1; ++i) {
        psl->array[i] = psl->array[i + 1];
    }
    psl->size--;
}

顺序表查找

// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x) {
    assert(psl);
    for (size_t i = 0; i < psl->size; ++i) {
        if (psl->array[i] == x) {
            return i;  // 返回找到的索引
        }
    }
    return -1;  // 未找到
}

在pos位置插入x

/ 在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x) {
    assert(psl);
    if (pos > psl->size) {
        printf("插入位置非法\n");
        return;
    }
    CheckCapacity(psl);
    // 移动元素
    for (size_t i = psl->size; i > pos; --i) {
        psl->array[i] = psl->array[i - 1];
    }
    psl->array[pos] = x;
    psl->size++;
}

删除pos位置的值

// 删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos) {
    assert(psl);
    if (pos >= psl->size) {
        printf("删除位置非法\n");
        return;
    }
    // 移动元素
    for (size_t i = pos; i < psl->size - 1; ++i) {
        psl->array[i] = psl->array[i + 1];
    }
    psl->size--;
}

销毁顺序表


// 顺序表销毁函数
void SeqListDestory(SeqList* psl) {
      assert(psl);

    //释放动态分配的数组内存
    //free 会回收 psl->array 指向的堆内存
    //注意：如果 array 本身是 NULL，free 不会报错但无意义
    free(psl->array);

    //将数组指针置空，避免野指针
    //防止后续误操作已释放的内存（如重复释放、非法访问）
    psl->array = NULL;

    //重置顺序表的元数据
    //将有效数据个数 (size) 和容量 (capacity) 归零
    //表示顺序表已被完全销毁，回到初始空状态
    psl->size = psl->capacity = 0;
}

顺序表打印

// 顺序表打印
void SeqListPrint(SeqList* psl) {
    assert(psl);
    printf("SeqList: [");
    for (size_t i = 0; i < psl->size; ++i) {
        printf("%d", psl->array[i]);
        if (i != psl->size - 1) {
            printf(", ");
        }
    }
    printf("] size=%zu, capacity=%zu\n", psl->size, psl->capacity);
}

这里还需要注意一点就是头删和尾删的时间复杂度和空间复杂度，头删时间复杂度为O（N^2）尾删那就是O（1），所以具体使用，还是得看题目的时间空间的要求来，不过现在空间不值钱了，我们一般都是空间换时间。

这里我们看了一些代码的实现，还是有一些问题：
1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

那么，就得用到，链表来解决了。

这里放张图，让大家自己思考