【数据结构】深入理解顺序表与通讯录项目的实现

重生之我是Java开发战士2025-08-12 8:22

文章目录

想象一下餐厅就餐的场景：如果没有排队机制，顾客会拥挤混乱，等餐时间变长，体验极差。程序中的数据也是如此------不经过合理组织，会导致数据丢失、操作困难，甚至出现野指针等致命错误。数据结构的核心价值就在于：

  • 高效存储数据
  • 方便快速查找
  • 支持灵活的增删改查操作

最基础的数据结构是数组，但它的局限性很大。比如当数组已满时，插入新数据需要手动扩容；频繁计算有效元素个数还会降低效率。这就是我们需要学习更高级结构的原因------顺序表就是数组的"升级版"。

一、顺序表的概念与结构

1. 线性表的基础

顺序表属于线性表 的一种。线性表是由n个相同特性的数据元素组成的有限序列，常见的还有链表、栈、队列等。它的逻辑结构是一条连续的直线，但物理存储方式可以是数组或链式结构。

  • 线性表物理结构不一定连续，逻辑结构是连续的。
  • 顺序表物理结构和逻辑结构都是连续的

2. 顺序表与数组的区别

顺序表的底层基于数组实现，但它对数组进行了封装，提供了更完善的操作接口。简单说：数组是原料，顺序表是加工后的成品。

比如数组只能通过下标访问，而顺序表会额外记录有效元素个数和容量，让数据管理更可控。

二、顺序表的分类

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，通常采用数组存储。根据存储空间的分配方式，可分为两类：

  • 静态顺序表：使用固定大小的数组存储数据，空间一旦确定无法更改
  • 动态顺序表：使用动态开辟的数组存储数据，可根据需要动态扩容，更灵活实用

本文重点实现动态顺序表，因为它能更好地适应数据量变化的场景。

三、顺序表的结构设计

首先我们需要定义顺序表的结构体，动态顺序表需要包含三个核心要素：

c 复制代码 
typedef int SLDataType;  // 数据类型别名，方便后续修改存储类型
struct SeqList
{
    SLDataType* arr;     // 指向动态开辟的数组
    int size;            // 有效数据个数
    int capacity;        // 容量大小（能存储的最大数据个数）
};
typedef struct SeqList SL;  // 重命名，简化代码

这样的设计有几个好处：

  • 使用SLDataType统一数据类型，后续要存储char或float只需修改这里
  • 分离size和capacity，清晰区分当前数据量和总容量
  • 用指针指向动态数组，实现存储空间的动态管理

四、核心功能实现

1. 初始化与销毁

初始化函数：将顺序表初始化为空状态

c 复制代码 
void SLInit(SL* p)  // 传地址而不是传值，因为要修改结构体内容
{
    p->arr = NULL;
    p->size = p->capacity = 0;  // 初始状态：无数据，容量为0
}

销毁函数：释放动态开辟的空间，避免内存泄漏

c 复制代码 
void SLDes(SL* p)
{
    if (p->arr)  // 如果数组存在，则释放
    {
        free(p->arr);
    }
    p->arr = NULL;  // 置空指针，避免野指针
    p->size = p->capacity = 0;  // 重置状态
}

2. 空间检查与扩容

动态顺序表的关键在于自动扩容，我们实现一个专门的函数来处理：

c 复制代码 
void checkCapacity(SL* p)
{
    assert(p);  // 确保指针有效
    
    // 当有效数据个数等于容量时，需要扩容
    if (p->size == p->capacity)
    {
        // 初始容量为4，之后每次翻倍
        int newCapacity = p->capacity == 0 ? 4 : 2 * p->capacity;
        
        // 使用realloc进行扩容（首次调用时相当于malloc）
        SLDataType* tmp = (SLDataType*)realloc(p->arr, newCapacity * sizeof(SLDataType));
        
        if (tmp == NULL)  // 检查扩容是否成功
        {
            perror("realloc fail!!");
            exit(1);  // 扩容失败则退出程序
        }
        // 扩容成功，更新指针和容量
        p->arr = tmp;
        p->capacity = newCapacity;
    }
}

为什么选择2倍扩容？这是一种时间和空间效率平衡的策略，既能减少频繁扩容的开销，又不会过度浪费空间。

3. 插入操作

尾插

c 复制代码 
void SLPushBack(SL* p, SLDataType x)
{
    assert(p);
    checkCapacity(p);  // 先检查空间
    p->arr[p->size] = x;  // 直接在末尾赋值
    ++p->size;  // 有效数据个数加 1
}

头插

c 复制代码 
void SLPushFront(SL* p, SLDataType x)
{
    assert(p);
    checkCapacity(p);
    // 从最后一个元素开始，依次向后移动一位
    for (int i = p->size; i >= 1; i--)
    {
        p->arr[i] = p->arr[i - 1];
    }
    p->arr[0] = x;  // 头部位置赋值
    p->size++;  // 更新数据个数
}

指定位置之前插入

c 复制代码 
void SLInsert(SL* p, int pos, SLDataType x)
{
    assert(p);
    assert(pos >= 0 && pos <= p->size);  // 确保位置有效
    
    checkCapacity(p);
    // 从最后一个元素到pos位置，依次后移
    for (int i = p->size; i > pos; i--)
    {
        p->arr[i] = p->arr[i - 1];
    }
    p->arr[pos] = x;  // 在pos位置插入新元素
    p->size++;
}

4. 删除操作

尾删

c 复制代码 
void SLPopBack(SL* p)
{
    assert(p);
    assert(p->size);  // 确保顺序表不为空
    p->size--;  // 只需将有效数据个数减1（逻辑删除）
}

头删

c 复制代码 
void SLPopFront(SL* p)
{
    assert(p);
    assert(p->size);  // 确保顺序表不为空
    // 从第二个元素开始，依次向前移动一位
    for (int i = 0; i < p->size - 1; i++)
    {
        p->arr[i] = p->arr[i + 1];
    }
    p->size--;  // 更新数据个数
}

指定位置删除

c 复制代码 
void SLErase(SL* p, int pos)
{
    assert(p);
    assert(p->size);  // 确保顺序表不为空
    assert(pos >= 0 && pos < p->size);  // 确保位置有效
    
    // 从pos位置开始，依次用后一个元素覆盖前一个
    for (int i = pos; i < p->size - 1; i++)
    {
        p->arr[i] = p->arr[i + 1];
    }
    p->size--;
}

5. 查找与打印

查找元素：返回元素所在位置，未找到返回-1

c 复制代码 
int SLFind(SL* p, SLDataType x)
{
    assert(p);
    for (int i = 0; i < p->size; i++)
    {
        if (p->arr[i] == x)
            return i;
    }
    return -1;  // 未找到
}

打印顺序表：遍历输出所有元素

c 复制代码 
void SLPrint(SL s)
{
    for (int i = 0; i < s.size; i++)
    {
        printf("%d ", s.arr[i]);
    }
    printf("\n");
}

五、测试代码与运行结果

我们编写测试函数来验证各个功能：

c 复制代码 
void SLtest01()
{
    SL s1;
    SLInit(&s1);  // 初始化
    
    // 尾插测试
    SLPushBack(&s1, 1);
    SLPushBack(&s1, 2);
    SLPushBack(&s1, 3);
    SLPushBack(&s1, 4);
    SLPushBack(&s1, 5);
    SLPrint(s1);  // 输出：1 2 3 4 5
    
    // 指定位置插入测试
    SLInsert(&s1, 0, 9);  // 头部插入
    SLPrint(s1);  // 输出：9 1 2 3 4 5
    SLInsert(&s1, s1.size, 6);  // 尾部插入（等价于尾插）
    SLPrint(s1);  // 输出：9 1 2 3 4 5 6
    
    // 指定位置删除测试
    SLErase(&s1, 1);  // 删除索引1的元素
    SLPrint(s1);  // 输出：9 2 3 4 5 6
    SLErase(&s1, 2);  // 删除索引2的元素
    SLPrint(s1);  // 输出：9 2 4 5 6
    SLErase(&s1, s1.size-1);  // 删除最后一个元素
    SLPrint(s1);  // 输出：9 2 4 5
    
    // 查找测试
    int find = SLFind(&s1, 4);
    printf("%d\n", find);  // 输出：2（元素4在索引2位置）
    
    SLDes(&s1);  // 销毁
}

六、顺序表的实战应用：通讯录项目

1. 项目需求

实现一个具有以下功能的通讯录：

  1. 存储至少100个人的通讯信息
  2. 保存信息包括：名字、性别、年龄、电话、地址等
  3. 支持增加、删除、查找、修改、显示联系人等操作
  4. 程序结束后，通讯录信息不丢失

2. 核心设计思路

（1）数据结构设计

首先定义联系人信息结构体：

c 复制代码 
#define NAME_MAX 100
#define SEX_MAX 4
#define TEL_MAX 11
#define ADDR_MAX 100

typedef struct PersonInfo {
    char name[NAME_MAX];  // 姓名
    char sex[SEX_MAX];    // 性别
    int age;              // 年龄
    char tel[TEL_MAX];    // 电话
    char addr[ADDR_MAX];  // 地址
} PeoInfo;

然后基于动态顺序表实现通讯录：

c 复制代码 
// 数据类型为PersonInfo
typedef struct PersonInfo SQDataType;

// 动态顺序表
typedef struct SeqList {
    SQDataType* a;      // 存储联系人数据
    int size;           // 有效联系人个数
    int capacity;       // 容量
} SLT;

// 通讯录类型定义
typedef struct SeqList contact;

（2）核心功能实现

  1. 初始化通讯录
c 复制代码 
void InitContact(contact* con) {
    SeqListInit(con);    // 初始化顺序表
    LoadContact(con);    // 加载历史数据
}
  1. 添加联系人
c 复制代码 
void AddContact(contact* con) {
    PeoInfo info;
    printf("请输入姓名:\n");
    scanf("%s", info.name);
    printf("请输入性别:\n");
    scanf("%s", info.sex);
    printf("请输入年龄:\n");
    scanf("%d", &info.age);
    printf("请输入联系电话:\n");
    scanf("%s", info.tel);
    printf("请输入地址:\n");
    scanf("%s", info.addr);
    
    SeqListPushBack(con, info);  // 尾插
    printf("插入成功!\n");
}
  1. 删除联系人
c 复制代码 
void DelContact(contact* con) {
    char name[NAME_MAX];
    printf("请输入要删除的用户姓名:\n");
    scanf("%s", name);
    
    int pos = FindByName(con, name);  // 查找位置
    if (pos < 0) {
        printf("要删除的用户不存在,删除失败!\n");
        return;
    }
    
    SeqListErase(con, pos);  // 删除指定位置元素
    printf("删除成功!\n");
}
  1. 数据持久化
    为了保证程序结束后数据不丢失，需要将数据保存到文件：
c 复制代码 
void SaveContact(contact* con) {
    FILE* pf = fopen("contact.txt", "wb");
    if (pf == NULL) {
        perror("fopen error!\n");
        return;
    }
    
    // 将通讯录数据写入文件
    for (int i = 0; i < con->size; i++) {
        fwrite(con->a + i, sizeof(PeoInfo), 1, pf);
    }
    
    printf("通讯录数据保存成功!\n");
    fclose(pf);
}

程序启动时加载数据：

c 复制代码 
void LoadContact(contact* con) {
    FILE* pf = fopen("contact.txt", "rb");
    if (pf == NULL) {
        printf("fopen error!\n");
        return;
    }
    
    // 循环读取文件数据
    PeoInfo info;
    while (fread(&info, sizeof(PeoInfo), 1, pf)) {
        SeqListPushBack(con, info);
    }
    
    printf("历史数据导入通讯录成功!\n");
    fclose(pf);
}
  1. 菜单交互
c 复制代码 
void menu() {
    contact con;
    InitContact(&con);
    int op = -1;
    
    do {
        printf("********************************\n");
        printf("*****1、添加用户 2、删除用户*****\n");
        printf("*****3、查找用户 4、修改用户*****\n");
        printf("*****5、展示用户 0、退出 *****\n");
        printf("********************************\n");
        
        printf("请选择您的操作:\n");
        scanf("%d", &op);
        
        switch (op) {
            case 1:
                AddContact(&con);
                break;
            case 2:
                DelContact(&con);
                break;
            case 3:
                FindContact(&con);
                break;
            case 4:
                ModifyContact(&con);
                break;
            case 5:
                ShowContact(&con);
                break;
            case 0:
                printf("退出程序\n");
                break;
            default:
                printf("输入有误,请重新输入\n");
                break;
        }
    } while (op != 0);
    
    // 销毁通讯录,同时保存数据
    DestroyContact(&con);
}

七、顺序表的问题与思考

优点：

  1. 随机访问：可以通过下标直接访问任意元素，时间复杂度O(1)
  2. 缓存友好：数据存储连续，充分利用CPU缓存，访问效率高
  3. 实现简单：相比链表，结构和操作更简单

缺点：

  1. 插入删除效率问题：中间或头部的插入删除操作需要移动大量元素，时间复杂度为O(N)
  2. 增容消耗：增容时需要申请新空间、拷贝数据、释放旧空间，会产生额外消耗
  3. 空间浪费：增容通常是2倍增长，可能导致部分空间闲置（例如容量从100增到200，却只再插入5个数据，就浪费了95个空间）

这些问题也引出了另一种重要的数据结构------链表，它在解决上述问题上有独特优势。在实际开发中，我们需要根据具体场景选择合适的数据结构。

总结

顺序表作为一种基础且重要的数据结构，通过对数组的封装，提供了更灵活、更易用的接口，非常适合实现如通讯录这类需要动态管理数据的应用。掌握顺序表不仅能帮助我们理解数据结构的核心思想------高效组织和管理数据，也为学习更复杂的数据结构（如链表、树、图等）打下坚实基础。

在实际开发中，没有完美的数据结构，只有最适合的选择。理解每种数据结构的优缺点，才能在面对具体问题时做出最优决策。

相关推荐
CoovallyAIHub24 分钟前
YOLO + DeepSort 的视频目标检测与跟踪全解析
深度学习·算法·计算机视觉
CoovallyAIHub1 小时前
基于YOLOv10-MHSA的“三北”工程内蒙古地区植树位点精准检测研究
深度学习·算法·计算机视觉
云和数据.ChenGuang2 小时前
Raft协议 一种专为分布式系统设计的共识算法
运维·服务器·算法·区块链·共识算法
anlogic4 小时前
Java基础 8.11
java·开发语言·算法
sjh21006 小时前
STM32的计数模式和pwm模式
java·stm32·算法
dlraba80212 小时前
机器学习-----K-means算法介绍
算法·机器学习·kmeans
啊阿狸不会拉杆13 小时前
《算法导论》第 14 章 - 数据结构的扩张
数据结构·c++·算法·排序算法
闪电麦坤9513 小时前
数据结构：栈（Stack）
数据结构
Q741_14714 小时前
如何判断一个数是 2 的幂 / 3 的幂 / 4 的幂 / n 的幂 位运算 总结和思考 每日一题 C++的题解与思路
开发语言·c++·算法·leetcode·位运算·总结思考
热门推荐
01全球最强模型Grok4，国内已可免费使用！（附教程）02UV安装并设置国内源03Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code04[已解决]VSCode右键菜单消失恢复05🚀Cursor CLI+GPT-5保姆级教程+编程能力测评！Cursor CLI零成本免费使用GPT-5！Claude Code的劲敌来了！从安装到实战演示06GPT-5 使用限制与国内升级全攻略（免费 / Plus / Pro）【2025 最新】072025最新国内服务器可用docker源仓库地址大全（2025年8月更新）08KGG转MP3工具|非KGM文件|解密音频09Cursor 终端“卡死/无响应”问题的解法10OpenAI重返开源！GPT-OSS本地部署完全指南