顺序表简介（新手仅需了解即可）

一、顺序表的核心原理

1. 存储方式

• 物理结构：数据元素存储在连续的内存块中（类似数组）。
• 逻辑结构：元素按照线性顺序排列，每个元素有唯一的前驱和后继（除首尾元素）。

2. 核心特性

• 随机访问：通过下标（索引）直接访问元素，时间复杂度为 O(1)。
• 连续存储：插入或删除元素时可能需要移动大量元素，时间复杂度为 O(n)。
• 容量管理：
  • 静态顺序表：容量固定（如 int data[100]），无法动态扩展。
  • 动态顺序表：容量可动态调整（如 vector），通过 realloc 或 new 扩容。

二、顺序表的实现（C++示例）

1. 结构定义

动态顺序表需记录：数据指针、当前元素个数（size）、总容量（capacity）。

typedef int SLDataType;  // 顺序表存储的数据类型（可自定义）

struct SeqList {
    SLDataType* data;    // 动态数组指针
    int size;            // 当前元素个数
    int capacity;        // 总容量
};

// 初始化顺序表
void SLInit(SeqList* ps) {
    ps->data = nullptr;
    ps->size = 0;
    ps->capacity = 0;
}

2. 基本操作

(1) 扩容机制

当 size == capacity 时触发扩容（通常扩容为原容量的 2 倍）。

void SLCheckCapacity(SeqList* ps) {
    if (ps->size == ps->capacity) {
        int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        SLDataType* newData = new SLDataType[newCapacity];  // C++风格动态内存
        if (ps->data != nullptr) {
            memcpy(newData, ps->data, ps->size * sizeof(SLDataType));
            delete[] ps->data;  // 释放旧内存
        }
        ps->data = newData;
        ps->capacity = newCapacity;
    }
}

2) 尾插元素

时间复杂度：均摊 O(1)（扩容时 O(n)）。

void SLPushBack(SeqList* ps, SLDataType x) {
    SLCheckCapacity(ps);
    ps->data[ps->size] = x;
    ps->size++;
}

(3) 指定位置插入

时间复杂度：O(n)（需移动元素）。

void SLInsert(SeqList* ps, int pos, SLDataType x) {
    if (pos < 0 || pos > ps->size) return;  // 检查越界
    SLCheckCapacity(ps);
    // 将pos后的元素后移
    for (int i = ps->size; i > pos; i--) {
        ps->data[i] = ps->data[i - 1];
    }
    ps->data[pos] = x;
    ps->size++;
}

(4) 删除元素

时间复杂度：O(n)（需移动元素）。

void SLErase(SeqList* ps, int pos) {
    if (pos < 0 || pos >= ps->size) return;  // 检查越界
    for (int i = pos; i < ps->size - 1; i++) {
        ps->data[i] = ps->data[i + 1];
    }
    ps->size--;
}

(5) 查找元素

时间复杂度：O(n)。

int SLFind(SeqList* ps, SLDataType x) {
    for (int i = 0; i < ps->size; i++) {
        if (ps->data[i] == x) return i;
    }
    return -1;  // 未找到
}

(6) 销毁顺序表

void SLDestroy(SeqList* ps) {
    if (ps->data != nullptr) {
        delete[] ps->data;  // 释放动态数组
        ps->data = nullptr;
    }
    ps->size = 0;
    ps->capacity = 0;
}

三、C++中的顺序表实现

C++标准库中的 std::vector 是动态顺序表的经典实现，支持自动扩容、迭代器访问等高级功能：

#include <vector>
using namespace std;

int main() {
    vector<int> vec;          // 初始化
    vec.push_back(10);        // 尾插
    vec.insert(vec.begin(), 5); // 头插
    vec.erase(vec.begin());   // 删除第一个元素
    return 0;
}

总结

顺序表是理解数据结构的基础，其核心是数组+动态扩容。