数据结构：顺序表

1.概念：

顺序表是一种线性表的存储结构，它使用一段连续的存储空间来存储数据元素。顺序表的特点是：

1. 逻辑上相邻的元素在物理存储上也相邻。

2. 支持随机访问，可以通过下标直接访问元素。

3. 插入和删除操作可能需要移动大量元素，时间复杂度较高。

2.基本操作：

顺序表的基本操作包括：

1. 初始化：创建一个空的顺序表。

2. 插入：在指定位置插入一个元素。

3. 删除：删除指定位置的元素。

4. 查找：根据值或下标查找元素。

5. 修改：修改指定位置的元素。

6. 遍历：访问顺序表中的所有元素。

7. 销毁：释放顺序表占用的内存。

3.代码实现：

#include 
#include 
#define MAX_SIZE 100 // 定义顺序表的最大容量

typedef struct {
    int data[MAX_SIZE]; // 用数组存储数据
    int length;         // 当前顺序表的长度
} SeqList;

// 初始化顺序表
void InitList(SeqList* L) {
    L->length = 0; // 初始长度为 0
}

// 插入元素
int InsertList(SeqList* L, int pos, int value) {
    if (pos < 1 || pos > L->length + 1) {
        printf("插入位置不合法\n");
        return 0; // 插入失败
    }
    if (L->length >= MAX_SIZE) {
        printf("顺序表已满，无法插入\n");
        return 0; // 插入失败
    }
    // 将插入位置后的元素向后移动
    for (int i = L->length; i >= pos; i--) {
        L->data[i] = L->data[i - 1];
    }
    L->data[pos - 1] = value; // 插入新元素
    L->length++;              // 长度加 1
    return 1; // 插入成功
}

// 删除元素
int DeleteList(SeqList* L, int pos) {
    if (pos < 1 || pos > L->length) {
        printf("删除位置不合法\n");
        return 0; // 删除失败
    }
    // 将删除位置后的元素向前移动
    for (int i = pos; i < L->length; i++) {
        L->data[i - 1] = L->data[i];
    }
    L->length--; // 长度减 1
    return 1; // 删除成功
}

// 查找元素（按值查找）
int FindList(SeqList* L, int value) {
    for (int i = 0; i < L->length; i++) {
        if (L->data[i] == value) {
            return i + 1; // 返回元素位置（从 1 开始）
        }
    }
    return -1; // 未找到
}

// 修改元素
int ModifyList(SeqList* L, int pos, int value) {
    if (pos < 1 || pos > L->length) {
        printf("修改位置不合法\n");
        return 0; // 修改失败
    }
    L->data[pos - 1] = value; // 修改元素
    return 1; // 修改成功
}

// 遍历顺序表
void PrintList(SeqList* L) {
    printf("顺序表内容：");
    for (int i = 0; i < L->length; i++) {
        printf("%d ", L->data[i]);
    }
    printf("\n");
}

int main() {
    SeqList L;
    InitList(&L); // 初始化顺序表

    // 插入元素
    InsertList(&L, 1, 10);
    InsertList(&L, 2, 20);
    InsertList(&L, 3, 30);
    PrintList(&L); // 输出：10 20 30

    // 删除元素
    DeleteList(&L, 2);
    PrintList(&L); // 输出：10 30

    // 查找元素
    int pos = FindList(&L, 30);
    if (pos != -1) {
        printf("元素 30 的位置：%d\n", pos); // 输出：元素 30 的位置：2
    }

    // 修改元素
    ModifyList(&L, 1, 100);
    PrintList(&L); // 输出：100 30

    return 0;
}

运行结果 

顺序表内容：10 20 30 
顺序表内容：10 30 
元素 30 的位置：2
顺序表内容：100 30 

 4.优缺点：

优点：

1. 随机访问：可以通过下标直接访问元素，时间复杂度为 O(1)O(1)。

2. 存储效率高：数据存储在一段连续的内存中，不需要额外的指针空间。

缺点：

1. 插入和删除效率低：需要移动大量元素，时间复杂度为 O(n)O(n)。

2. 容量固定：顺序表的大小通常是固定的，扩容时需要重新分配内存并复制数据。

 5.适用场景：

• 需要频繁访问元素，而插入和删除操作较少的场景。

• 数据量较小且已知最大容量的场景。

如果数据量较大或需要频繁插入和删除，可以考虑使用链表。