【数据结构】顺序表

拉普达的城2023-10-20 9:29

前言

顺序表是线性表的一种，而线性表是一种数据结构。顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接⼝。顺序表主要特点是内存存储是连续的，数据元素都是首尾相接的。

文章目录

一、顺序表介绍

顺序表分为静态顺序表和动态顺序表。

静态顺序表： 顺序表大小固定

c 复制代码 
typedef int SLDataType;
#define N 7

typedef struct SeqList {
	SLDataType a[N];//定长数组
	int size;//有效数据个数
}SL;

动态顺序表： 通过动态开辟内存，可随时扩大容量

c 复制代码 
typedef int SLDataType;

typedef struct SeqList {
	SLDataType* a; //定长数组
	int size;      //有效数据个数
	int capacity;  //当前数据容量
}SL;

二、动态顺序表的实现

顺序表通常有以下操作:

  1. 插入：在指定位置插入一个新元素。
  2. 删除：删除指定位置的元素。
  3. 查找：查找指定元素并返回其位置。
  4. 遍历：访问线性表中的每一个元素。

2.1 动态顺序表的定义

顺序表通常有三个属性，data指向动态分配数组的指针，用于存储元素，size表中当前存储的元素数量，capacity是当前分配的数组容量。

因为不同的人用顺序表存储的元素的类型不一定一样，为了方便使用，应将数据类型重命名，再次使用时只需要将 typedef int SLDataType 中的 int 改成需要的类型。

c 复制代码 
//动态顺序表
typedef int SLDataType;//数据类型重命名，方便重复使用顺序表
typedef struct SequenceList
{
	SLDataType* data;
	int size;  //顺序表中有效的数据个数
	int capacity;  //顺序表当前的空间大小
}SList;

2.2 初始化和销毁

初始化

初始化时，选择为list动态分配内存的好处是，对于需要大量内存的数据结构，使用堆通常是唯一的选择

list存放在栈中的好处是，不需要在使用完List后释放空间，还有栈上的内存分配和释放通常比堆上的快

c 复制代码 
//初始化
void initSeqList(SList* list) {
    assert(list);
    //SList *list = (SList*)malloc(sizeof(SList));
    list->data = (int*)malloc(sizeof(int)); 
    list->size = 0;
    list->capacity = 1;
}

销毁

在销毁要注意的是，在释放空间后，不要忘记给list赋NULL

c 复制代码 
//销毁
void destroySeqList(SList* list) {
    assert(list);
    if (list->data) {
        free(list->data);  // 释放动态数组的内存
        list->data = NULL; // 防止野指针
    }
    list = NULL; // 防止野指针
}

2.3 扩容

通常扩容选择原容量的1.5倍或者2倍进行扩容

c 复制代码 
//扩容
int resizeSeqList(SList* list) {
    assert(list);
    int newCapacity = list->capacity * 2;//通常扩容选择1.5倍或者2倍进行扩容
    
    int* newData = (int*)realloc(list->data, sizeof(int) * newCapacity);
    if (newData == NULL) {
        printf("内存分配失败\n");
        return -1;
    }

    list->data = newData;
    list->capacity = newCapacity;
    return 0;
}

2.4 插入

c 复制代码 
// 插入
int insertSeqList(SList* list, int index, int value) {
    assert(list);
    if (index < 0 || index > list->size) {
        return -1;
    }

    if (list->size >= list->capacity) { //如果容量不足，进行扩容
        if (resizeSeqList(list) == -1) {
            return -1; // 扩容失败
        }
    }

    for (int i = list->size; i > index; i--) {//将数据插入该位置，该位置及后面的数据向后移
        list->data[i] = list->data[i - 1];
    }
    list->data[index] = value;
    list->size++; //有效数据+1
    return 0;
}

2.5 删除

c 复制代码 
// 删除
int deleteSeqList(SList* list, int index) {
    assert(list);
    if (index < 0 || index >= list->size) {
        return -1;
    }
    for (int i = index; i < list-> size ; i++) {//将要删除的数据后面的数据往前移
        list->data[i] = list->data[i + 1];
    }
    list->size--;
    return 0;
}

2.6 查找

c 复制代码 
// 查找
int findSeqList(SList* list, int value) {
    assert(list);
    for (int i = 0; i < list->size; i++) {
        if (list->data[i] == value) {
            printf("找到目标数据，在第%d个\n", i + 1);
            return i;
        }
    }
    printf("未找到目标数据\n");
    return -1;
}

2.7 打印

c 复制代码 
// 打印
void printSeqList(SList* list) {
    assert(list);
    for (int i = 0; i < list->size; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");

2.8 主函数

c 复制代码 
#include"SeqList.h"

int main() {
    SList list;
    initSeqList(&list);
    insertSeqList(&list, 0, 1);
    insertSeqList(&list, 1, 2);
    insertSeqList(&list, 2, 3);
    printSeqList(&list);

    deleteSeqList(&list, 1);
    printSeqList(&list);

    findSeqList(&list,2);

    destroySeqList(&list);
   
	return 0;
}

运行结果：

三、完整代码

"SeqList.h"

c 复制代码 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//动态顺序表
typedef int SLDataType;//数据类型重命名，方便重复使用顺序表
typedef struct SequenceList
{
	SLDataType* data;
	int size;  //顺序表中有效的数据个数
	int capacity;  //顺序表当前的空间大小
}SList;

// 对顺序表进行初始化
void initSeqList(SList* list);

// 扩容
int resizeSeqList(SList* list);

// 插入
int insertSeqList(SList* list, int index, int value);

// 删除
int deleteSeqList(SList* list, int index);

// 查找
int findSeqList(SList* list, int value);

// 打印
void printSeqList(SList* list);

//销毁
void destroySeqList(SList* list);

"SeqList.c"

c 复制代码 
#include"SeqList.h"

//初始化
void initSeqList(SList* list) {
    assert(list);
    list->data = (int*)malloc(sizeof(int) * 2); 
    list->size = 0;
    list->capacity = 2;
}

//扩容
int resizeSeqList(SList* list) {
    assert(list);
    int newCapacity = list->capacity * 2;
    int* newData = (int*)realloc(list->data, sizeof(int) * newCapacity);//通常扩容选择1.5倍或者2倍进行扩容

    if (newData == NULL) {
        printf("内存分配失败\n");
        return -1;
    }

    list->data = newData;
    list->capacity = newCapacity;
    return 0;
}

// 插入
int insertSeqList(SList* list, int index, int value) {
    assert(list);
    if (index < 0 || index > list->size) {
        return -1;
    }

    if (list->size >= list->capacity) { //如果容量不足，进行扩容
        if (resizeSeqList(list) == -1) {
            return -1; // 扩容失败
        }
    }

    for (int i = list->size; i > index; i--) {//将数据插入该位置，该位置及后面的数据向后移
        list->data[i] = list->data[i - 1];
    }
    list->data[index] = value;
    list->size++; //有效数据+1
    return 0;
}

// 删除
int deleteSeqList(SList* list, int index) {
    assert(list);
    if (index < 0 || index >= list->size) {
        return -1;
    }
    for (int i = index; i < list-> size ; i++) {//将要删除的数据后面的数据往前移
        list->data[i] = list->data[i + 1];
    }
    list->size--;
    return 0;
}

// 查找
int findSeqList(SList* list, int value) {
    assert(list);
    for (int i = 0; i < list->size; i++) {
        if (list->data[i] == value) {
            printf("找到目标数据，在第%d个\n", i + 1);
            return i;
        }
    }
    printf("未找到目标数据\n");
    return -1;
}

// 打印
void printSeqList(SList* list) {
    assert(list);
    for (int i = 0; i < list->size; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

//销毁
void destroySeqList(SList* list) {
    assert(list);
    if (list->data) {
        free(list->data);  // 释放动态数组的内存
        list->data = NULL; // 防止野指针
    }
    list = NULL; // 防止野指针
}

"main.c"

c 复制代码 
#include"SeqList.h"

int main() {
    SList list;
    initSeqList(&list);
    insertSeqList(&list, 0, 1);
    insertSeqList(&list, 1, 2);
    insertSeqList(&list, 2, 3);
    printSeqList(&list);

    deleteSeqList(&list, 1);
    printSeqList(&list);

    findSeqList(&list,2);

    destroySeqList(&list);
   
	return 0;
}


如果你喜欢这篇文章，点赞👍+评论+关注⭐️哦！
欢迎大家提出疑问，以及不同的见解。

相关推荐
apocelipes1 天前
常用编程语言和库的正则表达式性能对比
c语言·c++·python·性能优化·golang·开发工具和环境
CSharp精选营4 天前
关系型 vs 非关系型：从原理到选型，一文搞定数据库核心分类
数据结构·nosql·关系型数据库·非关系型数据库·技术选型
刘马想放假7 天前
Modbus 全栈技术解析：TCP、RTU、ASCII、RTU over TCP
数据结构·网络协议
北域码匠8 天前
冒泡排序太慢？鸡尾酒排序双向优化，原生 C# 零第三方库完整代码
数据结构·排序算法·泛型·c# 算法·鸡尾酒排序·原生 c# 开发·冒泡排序优化·嵌入式算法
Darling噜啦啦15 天前
列表转树算法深度解析：从 Map 到 Reduce 的两种实现，面试高频考点
数据结构·算法·面试
LDR00616 天前
Type-C 快充全面升级！LDR6601 赋能个人护理便携电机，重塑剃须刀 / 理发器新体验
c语言·开发语言
小小工匠16 天前
Redis - 事务机制：能实现 ACID 属性吗
数据结构·redis·性能优化·并发·持久化
Luminous.16 天前
C语言--day30
c语言·开发语言
玖玥拾16 天前
C/C++ 数据结构（七）栈、容器适配器
c语言·数据结构·c++·栈·容器适配器
謓泽16 天前
C语言不是语法，是通往机器的地图。
c语言·开发语言
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf02GitHub 镜像站点03【AI】2026 年具身智能模型和世界模型总结042026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？052026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？06Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析072026 年 AI 大模型 & AI 编程工具实战全总结082026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？09AI科技热点日报 | 2026年07月01日10Trae国际版与国内版深度测评：AI原生IDE的双生花