顺序表实战：用C语言打造高效通讯录管理系统

顺序表这个数据结构，说白了就是一块连续内存、按下标存取的线性表。很多人在课上听完就过去了，觉得它也太简单了，不就是个数组嘛。但等到真正动手写项目，比如做一个通讯录管理系统，才发现代码一写就塌，要么不会动态扩容，要么一删除就出现内存碎片，要么查个联系人全靠遍历、卡到怀疑人生。我见过不少同学倒在这一步，也很少有人认真想过：为什么老师偏偏让你用顺序表来做通讯录，而不是链表、不是哈希表？

这篇就把这件事讲透。我会完整走一遍“顺序表实现高效通讯录”的实战流程，从数据结构定义、动态扩容、核心操作的代码实现，到性能实测、常见坑和扩展思路，全部基于我实际写过的版本。适合正在学数据结构的同学、准备课程设计的同学，以及想把顺序表用明白的开发者。你照着做，不仅能交上一份漂亮的作业，更重要的是搞清楚顺序表这个“最基础的结构”到底是怎么在业务里发挥作用的。

1. 为什么通讯录这类CRUD应用，天然适合用顺序表

先说结论：不是所有“表”都适合做通讯录，但通讯录的访问模式，恰好完美命中了顺序表的长处。

一个通讯录的核心操作无非就几种：添加联系人、删除联系人、按姓名或电话查找联系人、修改联系人信息、按索引浏览列表。很多人第一反应是“查找得用哈希表啊”，这话没错，但看场景。课程设计和大多数轻量级通讯录场景下，数据量撑死几千条，顺序查找的开销完全在可接受范围内。而顺序表真正厉害的地方是：按下标访问任意一条记录，时间复杂度是O(1)；尾部追加一条新记录，均摊下来也是O(1)级别。这两个特性，在通讯录这种“翻页浏览 + 快速新增”的业务里，体验非常好。

对比一下就清楚了。链表按索引访问要一路next，跳半天才能到第100个人；哈希表虽然查找快，但遍历和排序输出就很麻烦，你很难按“最近添加”或“字母顺序”给联系人列表排个序。而通讯录偏偏经常要做整表输出、按顺序展示、甚至按姓名排序。顺序表在内存中是连续的，遍历时可以充分利用CPU缓存预取，几千条数据哗啦一下就能全部渲染出来，这点在真实体验上远超链表。

还有一条很现实的原因：顺序表实现简单、代码量少、不容易出野指针。对正在学数据结构的人来说，能把一张连续内存的“表”玩明白，后续再去理解链表、二叉树、跳表，很多概念都是相通的。通讯录这种CRUD密集的项目，正好适合做顺序表的“练手舞台”。

当然，顺序表也不是银弹。如果联系人数量会暴涨到几十万甚至百万级，删除和插入频繁发生在表头时，顺序表移动元素的代价就很大。这个时候你可能会想要链表配合哈希索引的方案。但在项目正常的量级下，顺序表的效率优势远大于它的短板。

2. 数据结构设计：通讯录条目，不能只存姓名和电话

很多初版代码犯的第一个错，就是条目字段设计得太简陋。一个通讯录至少要支持“姓 名 / 手机号 / 分组 / 邮箱 / 备注”这些信息，不然做出来根本不像一个能用的应用。字段多几个，才能展示出顺序表“一条记录占固定大小”的格式化存储优势。

我把联系人定义为这样的结构体：

c复制#define MAX_NAME 32
#define MAX_PHONE 20
#define MAX_GROUP 16
#define MAX_EMAIL 32

typedef struct {
    int id;                // 编号，自增
    char name[MAX_NAME];   // 姓名
    char phone[MAX_PHONE]; // 手机号
    char group[MAX_GROUP]; // 分组，比如“同事”“家人”
    char email[MAX_EMAIL]; // 邮箱
} Contact;

id 这个人读友好字段很有用。删除、修改时用 id 定位，比直接用姓名定位更可靠，因为人名可能重复。分组字段则是为了后续扩展“按组筛选”功能时不需要改动底层结构。

接着定义顺序表本身。顺序表结构里最关键的两个变量是 length 和 capacity，前者表示当前有效数据条数，后者表示当前分配的内存能装下多少条。很多新手会忽略 capacity，导致超出容量后无脑越界写入。这是几乎所有顺序表项目崩溃的第一大原因。

c复制typedef struct {
    Contact *data;   // 指向连续内存区域
    int length;      // 当前联系人数量
    int capacity;    // 当前容量
} AddressBook;

这个设计背后有一个核心思路：把“逻辑长度”和“物理容量”解耦。用户只管往里面加数据，底层数组装不下时，由 AddressBook 自己负责扩容。这不只是工程上的便利，它把顺序表最精妙的部分——动态扩容——封装到了一个可控的位置。

容量初始给多少，我推荐10。不要上来就分配1000个元素的空间。顺序表的好处是“按需增长”，初始10条足够支撑日常测试，之后每满了就翻倍扩容，不会浪费内存，也能观察感受扩容机制是怎么运作的。

3. 核心操作逐个拆解：初始化、追加、查找、插入、删除

代码是我在Linux下用gcc写的C语言版本，把AddressBook封装成结构体，所有操作都通过函数完成。下面这段是基座部分：

c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 初始化通讯录
void addrbook_init(AddressBook *book) {
    book->capacity = INIT_CAPACITY;
    book->length = 0;
    book->data = (Contact *)malloc(sizeof(Contact) * book->capacity);
    if (book->data == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
}

// 释放内存
void addrbook_destroy(AddressBook *book) {
    free(book->data);
    book->data = NULL;
    book->length = 0;
    book->capacity = 0;
}

注意 addrbook_init 接收的是指针。C语言里结构体传参默认是值传递，如果你直接传 AddressBook book，函数内部改了 capacity，外面一点变化都没有。很多同学的bug源头就在这里。要么传指针，要么返回新结构体，我习惯传指针。

追加联系人的代码，我把它分成“先确保容量充足，再写入数据”两步：

c复制// 确保容量够用，不够就扩容
void addrbook_ensure_capacity(AddressBook *book) {
    if (book->length < book->capacity) {
        return;
    }
    int new_capacity = book->capacity * 2;
    Contact *new_data = (Contact *)realloc(book->data, sizeof(Contact) * new_capacity);
    if (new_data == NULL) {
        printf("扩容失败\n");
        exit(1);
    }
    book->data = new_data;
    book->capacity = new_capacity;
}

// 追加一条联系人
void addrbook_append(AddressBook *book, Contact *contact) {
    addrbook_ensure_capacity(book);
    book->data[book->length] = *contact;
    book->length++;
}

为什么扩容用realloc而不是malloc加memcpy？因为realloc在扩容时，如果原内存块后面恰好有空闲空间，它会原地扩展，不搬运数据，效率极高；即使需要搬迁，它也会自动完成旧的拷贝和释放。自己手动malloc + 拷贝 + free 非常容易漏掉free，造成内存泄漏。所以能用realloc就用realloc。

查找这个操作，我提供两个版本。按下标访问很简单，因为顺序表本身就是数组，直接 book->data[index] 就能O(1)拿到。按姓名查找，在不维护索引的情况下只能做顺序查找：

c复制// 按姓名查找，返回下标，找不到返回 -1
int addrbook_find_by_name(AddressBook *book, const char *name) {
    for (int i = 0; i < book->length; i++) {
        if (strcmp(book->data[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

这里有个小坑：字符串比较必须用 strcmp，不能用 if (book->data[i].name == name)。后者比较的是指针地址而不是内容。我见过不止一个人在这里翻车，排查了半天还以为是数据存错了。

插入操作比较有讲究。顺序表在中间插入，需要先把插入位置之后的元素统一后移，空出位置再写入，避免覆盖已有数据：

c复制// 在指定下标位置插入联系人，index合法范围为 0 ~ length
int addrbook_insert(AddressBook *book, int index, Contact *contact) {
    if (index < 0 || index > book->length) {
        return -1;
    }
    addrbook_ensure_capacity(book);
    // 从后往前搬移
    for (int i = book->length; i > index; i--) {
        book->data[i] = book->data[i - 1];
    }
    book->data[index] = *contact;
    book->length++;
    return 0;
}

搬移必须从后往前遍历。如果从前往后，后面的元素会被前面的覆盖掉，数据就错乱了。这个细节面试经常问，写代码时也最容易忽视。

删除操作是插入的逆过程，把后面的元素往前覆盖：

c复制// 删除指定下标的联系人
int addrbook_delete(AddressBook *book, int index) {
    if (index < 0 || index >= book->length) {
        return -1;
    }
    for (int i = index; i < book->length - 1; i++) {
        book->data[i] = book->data[i + 1];
    }
    book->length--;
    return 0;
}

删除时我特意没有立刻缩容。原因后面专门讲，这里先留个悬念。

4. 扩容机制：通讯录的“高效”到底从哪来

很多人以为顺序表效率高是“因为数组快”，其实只说对了一半。真正让顺序表适用于动态业务场景的关键，是它那套精心设计的扩容策略。

4.1 为什么初始容量不能设太大

如果把初始化容量设成10000，确实前期不会触发扩容，但会造成严重的内存浪费。一个只存了3个联系人的通讯录，却占了10000个Contact结构体的空间。每个Contact约100字节，10000条就是1MB，这在嵌入式或内存受限场景下是挥霍。

更好的做法是小步快跑。初始10条，满了扩到20、40、80，最后10000条时容量会稳定在16384左右，最多浪费空间约60%，但平均内存效率很高。而且小容量启动快，对函数调用栈和堆的压力也小。

4.2 扩容倍率选2倍还是1.5倍

扩容倍率是个经典的数学问题。选2倍，空间增长率是100%，实现简单，二进制友好；选1.5倍，内存回收时更容易复用之前释放的旧块，对内存碎片更友好。实际开发中Java的HashMap用2倍，Go的slice用1.5倍左右，各有道理。

在通讯录这个项目里，我直接用2倍。理由很实际：实现简单，old_capacity * 2不会出现浮点精度问题，而且课程设计阶段根本到不了内存碎片那个复杂程度。如果以后做高并发服务，再考虑1.5倍策略也不迟。

扩容的具体步骤，我建议写成addrbook_ensure_capacity独立函数，不要塞在append里。原因是插入和追加都需要先保证容量，抽出来可以复用。

4.3 均摊复杂度：为什么说尾插是O(1)

假设初始容量1，每满就翻倍。插入第1条时扩容到2，插入第2条时扩容到4，插入第3、4条不用扩，插入第5条时扩容到8……推导下来，插入n个元素总共触发约log2(n)次扩容。每次扩容的代价是拷贝当前所有元素。整体拷贝次数加起来大约是2n量级（等比数列求和），分摊到n次插入中，每次插入的均摊代价是O(1)。这就是“均摊复杂度”的精髓：虽然某一次插入可能非常慢，但平均下来很快。

这也是为什么你要用翻倍扩容而不是“每次加1”：每次加1，总拷贝次数是1+2+3+...+n=O(n^2)，均摊下来每次插入是O(n)，数据量一大必然卡死。

4.4 删除后为什么不要立刻缩容

删除元素后立刻缩容，比如删到只剩一半容量就realloc一次，会引发“缩容抖动”。假设你反复在容量边界上增删数据，比如容量到80，删除一个变成79，缩容到40；再加一个变成41，扩容到80……反复来回，每次操作都伴随着realloc和内存搬移，性能急剧劣化。

正确做法是：删除时不缩容，只在内部维护一个“低水位线”，比如实际使用量低于容量的1/4时再缩容到一半，这样能保证缩容之后还有充足的缓冲空间。项目里如果真的要做，可以在删除后加一个简单判断：

c复制// 删除后检查，如果实际数据量只有容量的1/4且容量大于初始值，缩容到一半
if (book->length < book->capacity / 4 && book->capacity > INIT_CAPACITY) {
    int new_capacity = book->capacity / 2;
    Contact *new_data = (Contact *)realloc(book->data, sizeof(Contact) * new_capacity);
    if (new_data != NULL) {
        book->data = new_data;
        book->capacity = new_capacity;
    }
}

注意realloc失败时不能直接覆盖原指针，否则原数据也丢了。这条我在后面踩坑部分细讲。

5. 实测对比：顺序表和链表的性能差距到底有多大

为了让自己信服，我写了一个简单的基准测试程序，分别用顺序表和单链表实现相同的通讯录操作：插入1万条、随机查找500次、按索引遍历全部数据。环境是Linux，gcc -O2编译，数据量1万条。

结果很直观：

注意那个删除表头的对比，顺序表删除表头需要把所有元素往前搬移，O(n)；链表只需要改头指针，O(1)。这也是所有顺序表项目的通病：头部或中间插入删除代价大。

通讯录的真实使用场景是什么？绝大多数操作是添加新联系人（尾插）、浏览列表（顺序遍历）、按姓名搜索（顺序查找）。头部删除并不是高频操作。所以哪怕链表删除表头快得离谱，在这个项目里也完全不重要。

这里有一个值得分享的经验：选型不是选“所有操作都快的数据结构”，而是选“高频操作最快的数据结构”。通讯录高频操作是尾插、遍历、查找，顺序表恰好全占了。

6. 学生党最容易踩的5个坑，含一个隐蔽的内存泄漏

这一节是血泪经验。下面这些问题我在批改代码和帮同学调bug时反复遇到，顺序表通讯录的段错误和质量分，基本都折在这儿。

6.1 结构体传值导致的“假初始化”

最经典的就是写 addrbook_init(book) 时忘了取地址，或者函数声明时形参写成了 AddressBook book。函数内部改了局部变量的capacity和data指针，外面的book纹丝不动。后续操作book时发现data未初始化，直接踩到野指针上。

排查方法很简单：在调用init之后打印book.capacity，如果还是0或者随机值，就说明传参出问题了。

6.2 删除后的缩容抖动

我在第4节讲过，这里不重复。记住一点：缩容是有代价的，必须结合“低水位线”规则，而不是用一次删一次。

6.3 strcmp用成了“==”

比较姓名时，很多第一次写C语言项目的新手会写：

c复制if (book->data[i].name == name)

这种比较的是两个字符串的首地址。name是外部传入的指针，data[i].name是数组的首地址，二者永远不相等。结果就是任何查询都返回找不到。

正确写法是 strcmp(book->data[i].name, name) == 0。

6.4 插入时从前往后搬移，把数据全覆盖了

这个比strcmp更隐蔽。看代码很难发现逻辑错误，但一运行，数据全是重复的。核心就是搬移顺序错了。插入必须从后往前，删除必须从前往后。

我记得有一次帮学弟调这个bug，他满脸困惑说“明明感觉逻辑没问题，但数据就是不对”。我把搬移动图一画，他就懂了。顺序表就是物理上的连续数组，搬移方向错了，数据就会被连环覆盖。

6.5 realloc后直接覆盖原指针，丢失内存

这是最隐蔽的内存泄漏，编译器不会报错，但运行久了内存越占越多。

c复制book->data = realloc(book->data, new_size);  // 错误写法

如果realloc失败，会返回NULL，同时原来的内存块仍然有效。这时候直接把NULL赋给book->data，原来的指针就丢了，以后既无法释放也无法访问，造成泄漏。

正确写法：

c复制Contact *new_data = realloc(book->data, new_size);
if (new_data != NULL) {
    book->data = new_data;
    book->capacity = new_capacity;
} else {
    // 保持原数据不变，可以尝试其他处理
}

7. 完整可运行的通讯录代码

把上面所有部分整合到一起，我整理了一个精简但完整的C语言版本，包含初始化、添加、查找、插入、删除、打印和释放，直接保存为 address_book.c 就能编译运行：gcc address_book.c -o address_book -std=c99。

c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NAME 32
#define MAX_PHONE 20
#define MAX_GROUP 16
#define MAX_EMAIL 32
#define INIT_CAPACITY 10

typedef struct {
    int id;
    char name[MAX_NAME];
    char phone[MAX_PHONE];
    char group[MAX_GROUP];
    char email[MAX_EMAIL];
} Contact;

typedef struct {
    Contact *data;
    int length;
    int capacity;
} AddressBook;

int next_id = 1;

void addrbook_init(AddressBook *book) {
    book->capacity = INIT_CAPACITY;
    book->length = 0;
    book->data = (Contact *)malloc(sizeof(Contact) * book->capacity);
    if (book->data == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
}

void addrbook_destroy(AddressBook *book) {
    free(book->data);
    book->data = NULL;
    book->length = 0;
    book->capacity = 0;
}

void addrbook_ensure_capacity(AddressBook *book) {
    if (book->length < book->capacity) {
        return;
    }
    int new_capacity = book->capacity * 2;
    Contact *new_data = (Contact *)realloc(book->data, sizeof(Contact) * new_capacity);
    if (new_data == NULL) {
        printf("扩容失败\n");
        exit(1);
    }
    book->data = new_data;
    book->capacity = new_capacity;
}

void addrbook_append(AddressBook *book, const char *name, const char *phone,
                     const char *group, const char *email) {
    addrbook_ensure_capacity(book);
    Contact *c = &book->data[book->length];
    c->id = next_id++;
    snprintf(c->name, MAX_NAME, "%s", name);
    snprintf(c->phone, MAX_PHONE, "%s", phone);
    snprintf(c->group, MAX_GROUP, "%s", group);
    snprintf(c->email, MAX_EMAIL, "%s", email);
    book->length++;
}

int addrbook_find_by_name(AddressBook *book, const char *name) {
    for (int i = 0; i < book->length; i++) {
        if (strcmp(book->data[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

int addrbook_insert(AddressBook *book, int index, const char *name, const char *phone,
                    const char *group, const char *email) {
    if (index < 0 || index > book->length) {
        return -1;
    }
    addrbook_ensure_capacity(book);
    for (int i = book->length; i > index; i--) {
        book->data[i] = book->data[i - 1];
    }
    Contact *c = &book->data[index];
    c->id = next_id++;
    snprintf(c->name, MAX_NAME, "%s", name);
    snprintf(c->phone, MAX_PHONE, "%s", phone);
    snprintf(c->group, MAX_GROUP, "%s", group);
    snprintf(c->email, MAX_EMAIL, "%s", email);
    book->length++;
    return 0;
}

int addrbook_delete(AddressBook *book, int index) {
    if (index < 0 || index >= book->length) {
        return -1;
    }
    for (int i = index; i < book->length - 1; i++) {
        book->data[i] = book->data[i + 1];
    }
    book->length--;
    return 0;
}

void addrbook_print(AddressBook *book) {
    printf("=== 通讯录共 %d 条记录 ===\n", book->length);
    for (int i = 0; i < book->length; i++) {
        Contact *c = &book->data[i];
        printf("id=%d | %s | %s | %s | %s\n",
               c->id, c->name, c->phone, c->group, c->email);
    }
}

int main(void) {
    AddressBook book;
    addrbook_init(&book);

    addrbook_append(&book, "张三", "13800000001", "同事", "zhangsan@example.com");
    addrbook_append(&book, "李四", "13800000002", "家人", "lisi@example.com");
    addrbook_append(&book, "王五", "13800000003", "朋友", "wangwu@example.com");

    // 在位置1插入一个联系人
    addrbook_insert(&book, 1, "赵六", "13800000004", "同事", "zhaoliu@example.com");

    // 按姓名查找
    int idx = addrbook_find_by_name(&book, "李四");
    if (idx >= 0) {
        printf("找到李四，下标=%d，电话=%s\n", idx, book.data[idx].phone);
    }

    // 删除王五
    idx = addrbook_find_by_name(&book, "王五");
    if (idx >= 0) {
        addrbook_delete(&book, idx);
    }

    addrbook_print(&book);
    addrbook_destroy(&book);
    return 0;
}

这个程序跑起来的输出大致是：

code复制找到李四，下标=2，电话=13800000002
=== 通讯录共 3 条记录 ===
id=1 | 张三 | 13800000001 | 同事 | zhangsan@example.com
id=4 | 赵六 | 13800000004 | 同事 | zhaoliu@example.com
id=2 | 李四 | 13800000002 | 家人 | lisi@example.com

可以看到王五被删除后，后面的李四被往前搬移，覆盖掉了原来的位置。整个过程顺滑、可控，这就是顺序表的基本功。

8. 项目还可以怎么扩展：从课程设计到真实工具

代码跑通只是第一步。如果你想把这个项目从“能跑”升级成“像一个真正的工具”，这几个方向是我实践后觉得性价比最高的。

8.1 支持文件存取

现在的数据在程序退出后就丢了。加一个保存到文件的功能，每次退出前把全部联系人写入CSV或二进制文件，启动时再加载回来。这个功能能让你真正把它当作一个日常工具来用。实现也不复杂：保存就是把length和所有Contact写入文件，加载就是读文件然后逐个append。

建议用CSV格式而不是自定义二进制，好处是能用Excel打开查看，调试时也方便。字段中间有逗号的话记得加转义。

8.2 按姓名顺序插入，做成“自动排序”

通讯录一般希望按拼音排序输出。实现思路有两个：一是每次插入后调用qsort按姓名排序；二是插入时利用顺序表的插入操作，找到合适的位置再插进去。第二种更符合“顺序表插入”的训练目的。

如果坚持用qsort，要注意中文字符串的排序依赖locale，排序结果在不同平台上可能不一样。简单起见可以先用英文名测试排序逻辑，再扩展到中文。

8.3 增加分组筛选功能

有了group字段，就可以实现“只看家人”“只看同事”这类过滤。因为顺序表是连续内存，用一层循环过滤非常高效。也可以建立一个“视图数组”，存满足条件的下标索引，方便快速切换分组而不影响原数据。

8.4 用二分查找优化按编号检索

如果通讯录按id天然有序，那查找id就完全可以用二分查找，复杂度从O(n)降到O(log n)。这是顺序表“支持随机访问”的真正威力。链表做不到这一点，因为它无法O(1)跳到中间位置。

c复制int addrbook_find_by_id(AddressBook *book, int target_id) {
    int left = 0, right = book->length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (book->data[mid].id == target_id) {
            return mid;
        } else if (book->data[mid].id < target_id) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

前提是id有序，上面代码里id自增，天然有序。

9. 写在最后的一点项目心得

顺序表通讯录这个项目，技术上并不难，但它是少有的能让你把“连续内存、下标访问、动态扩容、元素搬移”这四件事同时练个遍的题目。做一遍，你对数组的认知会从“一组变量”变成“一段可管理的内存”，这个转变对学后续数据结构的帮助非常大。

我的建议是：不要只抄上面的代码，去自己动手改，加上文件存取，试着把查找改成按电话匹配，再试试插入时保持姓名有序。踩两三次坑、看几次内存崩溃报错，你就真正吃透它了。如果过程中遇到问题，欢迎带着报错信息来交流，我看到的都会回。