【C语言数据结构】顺序表详解（动态版本）

已于 2023-12-14 16:55:13 修改
阅读量641 收藏 8
点赞数 4
分类专栏： C语言数据结构 文章标签： 数据结构 c语言
于 2023-03-17 17:14:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhgiuyawhiudwqha/article/details/129622208
版权
作者：热爱编程的小y
专栏：C语言数据结构
格言：能打败你的只能是明天的你

一、概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表是线性表的一种，他的孪生兄弟是链表。

二、结构

顺序表一般可以分为：

  1. 静态顺序表

使用定长数组存储元素。

  1. 动态顺序表

使用动态开辟的数组存储。

三、接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态地分配空间大小，所以下面我们实现动态顺序表。

（一）准备工作

1.创立文件

我们需要创立三个文件，分别是SeqList.c，SeqList.h，Test.c。

SeqList.h 内包含引用的头文件，函数的声明，结构体的声明，宏的声明与定义。

SeqList.c 内包含函数的主体，增删查改的具体过程在这里实现。

Test.c 负责对各项功能的测试与具体运用。

2.函数与结构体的定义

我们需要定义一个结构体类型用于数据的存放，结构体内需要包含三个参数，分别是一个指针，一个表示当前已存放的数据个数的整形，一个表示当前最多存放的数据个数的整形。因为我们不仅需要把数据存放进去，还要知道它的存放位置便于后续的更改，第三个参数则是确保开辟的空间大小在一个合理的范围内。具体如下。


typedef struct SeqList
{
    SLDateType* a;//存放数据的地址
    int size;//当前已存放的数据个数
    int capacity;//当前最多存放的数据个数
}SeqList;

因为我们并不能确定存放数据的类型是什么，所以我们需要重新命名一个类型，就像这样。


typedef int SLDateType;//想修改顺序表内数据的类型可以直接在这修改

之后不论是想存放什么类型的数据，只要在这里修改一遍就可以了。

我们还需要定义各种函数来分别实现各种功能，功能就不一一介绍了，具体如下。


// 对数据的管理:增删查改 
//初始化
void SeqListInit(SeqList* ps);

//销毁
void SeqListDestroy(SeqList* ps);

//显示(打印)
void SeqListPrint(SeqList* ps);

//尾插
void SeqListPushBack(SeqList* ps, SLDateType x);

//头插
void SeqListPushFront(SeqList* ps, SLDateType x);

//头删
void SeqListPopFront(SeqList* ps);

//尾删
void SeqListPopBack(SeqList* ps);

// 顺序表查找
void SeqListFind(SeqList* ps, SLDateType x);

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

（二）功能实现

  1. 初始化与销毁

我们先给定一个内存大小初始值，按照这个初始值通过malloc或者calloc函数给参数ps->a开辟空间，

#define INIT_CAPACITY 4

我们将初始值定义成一个宏，方便随时修改。

空间有开辟失败的可能性（虽然可能性很小很小就是了），因此还要对其进行排除。

销毁顺序表的时候我们用free函数来释放掉里面的空间，并顺带把原先指向存放数据地址的指针赋为空，避免其成为野指针。


//初始化
void SeqListInit(SeqList* ps)
{
    ps->a = (SLDateType*)malloc(INIT_CAPACITY * sizeof(SLDateType));
    if (NULL == ps->a)
    {
        perror("SeqListInit::calloc");
        return;
    }
    ps->size = 0;
    ps->capacity = INIT_CAPACITY;
    return;
}

//销毁
void SeqListDestroy(SeqList* ps)
{
    free(ps->a);
    ps->a = NULL;
    ps->capacity = ps->size = 0;
    return;
}

  1. 头插与尾插

先说明一下，头插就是在顺序表的开头插入数据，尾插则是在顺序的末尾插入数据。

我们进行头插操作时，因为不能直接硬插，而是要先腾出空间才能插入，而且不能打乱后面数据的顺序，所以我们需要把所有数据由末向前依次往后挪一个位置。结束之后要记得让size+1。

相比头插，尾插就方便多了，我们可以直接插入数据，因为size的值不仅是已有数据的个数也是我们插入的下一个数据的地址。

不管是头插还是尾插，我们都需要先进行一个判断是否扩容的操作，判断条件很简单，只需要判断size与capacity就是已有数据的个数与最大空间是否相等了即可。与开辟空间一样，扩容也存在失败的可能性，也需要进行排除。


//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
    /*增容*/
    if (ps->size == ps->capacity)
    {
        SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType)*ps->capacity * 2);
        /*增容失败*/
        if (tmp == NULL)
        {
            perror("SeqListPushFront::realloc");
            return;
        }
        /*增容成功*/
        ps->a = tmp;
        ps->capacity *= 2;
    }
    ps->a[ps->size++] = x;
    return;
}

//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
    /*扩容*/
    if (ps->size == ps->capacity || ps->size + 1 == ps->capacity)
    {
        SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
        /*增容失败*/
        if (tmp == NULL)
        {
            perror("SeqListPushFront::realloc");
            return;
        }
        /*增容成功*/
        ps->a = tmp;
        ps->capacity *= 2;
    }
    int i = 0;
    for (i = ps->size; i>0; i -- )
    {
        ps->a[i] = ps->a[i - 1];
    }
    ps->a[0] = x;
    ps->size++;
    return;
}

  1. 头删与尾删

在进行头删操作的时候，我们就不需要像头插一样考虑空间的问题了，我们只需要对头部数据进行重新赋值，效果就等同于删除了。因此我们需要从第二个数据开始，赋值给它的前一个数据，依次向后推，直到最后一个数据也完成对前一个数据的赋值为之。

尾插则更简单了，只需要让控制顺序表数据个数的size-1即可。

注意：在进行上述删除操作之前，都需要对size的值进行一个判断，当它为0时理应终止删除，即让size停止自减操作，否则size有可能减成负数，而导致后续插入操作出现问题。


//尾删
void SeqListPopBack(SeqList* ps)
{
    if (0 == ps->size)
        return;
    ps->size--;
}

//头删
void SeqListPopFront(SeqList* ps)
{
    if (0 == ps->size)
        return;
    int i = 0;
    for (i = 0; i < ps->size - 1; i++)
    {
        ps->a[i] = ps->a[i + 1];
    }
    ps->size--;
    return;
}

  1. 在指定位置插入与删除

不同于尾插尾删，要想在指定位置进行数据的插入与删除，需要考虑后面数据的影响，因此它与头插头删类似，只不过起始地址不同罢了。

类似于头插，在指定位置插入时，也要把后续数据不变顺序地向后挪一个空间，再把新数据插入到空出来的那个空间当中

类似于头删，我们只需要从指定位置的后一个数据开始，向前赋值，依次往后直到最后一个数据。


//在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
    /*扩容*/
    if (ps->size == ps->capacity || ps->size + 1 == ps->capacity)
    {
        SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
        /*增容失败*/
        if (tmp == NULL)
        {
            perror("SeqListPushFront::realloc");
            return;
        }
        /*增容成功*/
        ps->a = tmp;
        ps->capacity *= 2;
    }
    int i = 0;
    for (i = ps->size; i > pos; i--)
    {
        ps->a[i] = ps->a[i - 1];
    }
    ps->a[pos] = x;
    ps->size++;
    return;
}

//删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
    if (0 == ps->size)
        return;
    if (pos > ps->size-1)
        return;
    int i = 0;
    for (i = pos; i < ps->size-1; i++)
    {
        ps->a[i] = ps->a[i + 1];
    }
    ps->size--;
    return 0;
}

  1. 数据的显示与查找

显示与查找操作比较简单，都只用直接打印出来即可，就不过多介绍了，直接看代码。


//显示(打印)
void SeqListPrint(SeqList* ps)
{
    for (int i = 0; i < ps->size; i++)
    {
        printf("%d ", ps->a[i]);
    }
    printf("\n");
    return;
}

//查找
void SeqListFind(SeqList* ps, SLDateType x)
{
    int i = 0, flag = 0;
    for (i = 0; i < ps->size; i++)
    {
        if (x == ps->a[i])
        {
            printf("找到了，下标是：%d\n", i);
            flag++;
        }
    }
    if (flag == 0)
        printf("没找到\n");
    return;
}

四、代码呈现

最后附上完整代码：


SeqList.h部分
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#define INIT_CAPACITY 4

typedef int SLDateType;//想修改顺序表内数据的类型可以直接在这修改
typedef struct SeqList
{
    SLDateType* a;//存放数据的地址
    int size;//当前已存放的数据个数
    int capacity;//当前最多存放的数据个数
}SeqList;

// 对数据的管理:增删查改 
//初始化
void SeqListInit(SeqList* ps);

//销毁
void SeqListDestroy(SeqList* ps);

//显示(打印)
void SeqListPrint(SeqList* ps);

//尾插
void SeqListPushBack(SeqList* ps, SLDateType x);

//头插
void SeqListPushFront(SeqList* ps, SLDateType x);

//头删
void SeqListPopFront(SeqList* ps);

//尾删
void SeqListPopBack(SeqList* ps);

// 顺序表查找
void SeqListFind(SeqList* ps, SLDateType x);

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

SeqList.c部分
#pragma once
#include"SeqList.h"

//初始化
void SeqListInit(SeqList* ps)
{
    ps->a = (SLDateType*)malloc(INIT_CAPACITY * sizeof(SLDateType));
    if (NULL == ps->a)
    {
        perror("SeqListInit::calloc");
        return;
    }
    ps->size = 0;
    ps->capacity = INIT_CAPACITY;
    return;
}

//销毁
void SeqListDestroy(SeqList* ps)
{
    free(ps->a);
    ps->a = NULL;
    ps->capacity = ps->size = 0;
    return;
}

//显示(打印)
void SeqListPrint(SeqList* ps)
{
    for (int i = 0; i < ps->size; i++)
    {
        printf("%d ", ps->a[i]);
    }
    printf("\n");
    return;
}

//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
    /*增容*/
    if (ps->size == ps->capacity)
    {
        SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType)*ps->capacity * 2);
        /*增容失败*/
        if (tmp == NULL)
        {
            perror("SeqListPushFront::realloc");
            return;
        }
        /*增容成功*/
        ps->a = tmp;
        ps->capacity *= 2;
    }
    ps->a[ps->size++] = x;
    return;
}

//尾删
void SeqListPopBack(SeqList* ps)
{
    if (0 == ps->size)
        return;
    ps->size--;
}

//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
    /*扩容*/
    if (ps->size == ps->capacity || ps->size + 1 == ps->capacity)
    {
        SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
        /*增容失败*/
        if (tmp == NULL)
        {
            perror("SeqListPushFront::realloc");
            return;
        }
        /*增容成功*/
        ps->a = tmp;
        ps->capacity *= 2;
    }
    int i = 0;
    for (i = ps->size; i>0; i -- )
    {
        ps->a[i] = ps->a[i - 1];
    }
    ps->a[0] = x;
    ps->size++;
    return;
}

//头删
void SeqListPopFront(SeqList* ps)
{
    if (0 == ps->size)
        return;
    int i = 0;
    for (i = 0; i < ps->size - 1; i++)
    {
        ps->a[i] = ps->a[i + 1];
    }
    ps->size--;
    return;
}

//查找
void SeqListFind(SeqList* ps, SLDateType x)
{
    int i = 0, flag = 0;
    for (i = 0; i < ps->size; i++)
    {
        if (x == ps->a[i])
        {
            printf("找到了，下标是：%d\n", i);
            flag++;
        }
    }
    if (flag == 0)
        printf("没找到\n");
    return;
}

//在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
    /*扩容*/
    if (ps->size == ps->capacity || ps->size + 1 == ps->capacity)
    {
        SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
        /*增容失败*/
        if (tmp == NULL)
        {
            perror("SeqListPushFront::realloc");
            return;
        }
        /*增容成功*/
        ps->a = tmp;
        ps->capacity *= 2;
    }
    int i = 0;
    for (i = ps->size; i > pos; i--)
    {
        ps->a[i] = ps->a[i - 1];
    }
    ps->a[pos] = x;
    ps->size++;
    return;
}

//删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
    if (0 == ps->size)
        return;
    if (pos > ps->size-1)
        return;
    int i = 0;
    for (i = pos; i < ps->size-1; i++)
    {
        ps->a[i] = ps->a[i + 1];
    }
    ps->size--;
    return 0;
}
谁在夜里看海.
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
详解（数据结构C语言版）顺序表
10-02
顺序表演示程序
『初阶数据结构 • C语言』⑧ - 动态顺序表详解（附完整源码）
花想云的博客
01-13 1433
上一章我们学习了静态顺序表的增删查改，并认识了静态顺序表的存储结构与静态顺序表的在不同场景下的优劣。静态顺序表与动态顺序表都叫做顺序表，只不过我们平时口头所提的顺序表指的是动态顺序表。
动态顺序表的C语言实现（详细）
qq_983030560的博客
11-28 2115
顺序表的C语言实现
【数据结构】实现动态顺序表及详细讲解
Eraser的博客
05-04 619
数据结构的常见线性表，分别是顺序表，链表，栈，队列 本篇给大家带来动态顺序表的实现和讲解
C语言详解 顺序表的功能实现
卜及中的博客
01-24 445
本文主要介绍了顺序表的概念和动态的好处以及相应操作及功能的实现（附完整代码）
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 2845
轻松带你搞定顺序表！
C语言实现静态顺序表的实例详解
08-29
在计算机科学中，顺序表是一种基本的数据结构，它是由一系列元素组成的有序集合。静态顺序表是一种特殊的顺序表，它在内存中开辟了一段连续的存储空间，并给它一个名字进行标识。下面我们将深入探讨C语言实现静态...
C语言数据结构 链表与归并排序实例详解
12-31
C语言数据结构 链表与归并排序实例详解 归并排序适合于对链表进行原址排序，即只改变指针的连接方式，不交换链表结点的内容。 归并排序的基本思想是分治法：先把一个链表分割成只有一个节点的链表，然后按照一定顺序...
C语言线性表顺序存储结构实例详解
08-30
本资源为C语言线性表顺序存储结构实例详解，涵盖了顺序存储结构的定义、线性表的顺序存储结构的实现、顺序表的初始化操作、获取元素操作、插入操作和删除元素操作等方面，为学习C语言线性表顺序存储结构的朋友提供了...
C语言数据结构之 折半查找实例详解
08-30
折半查找实例详解 折半查找是一种常用的查找算法，它可以快速地在有序表中查找目标元素。下面是关于折半查找的详细知识点： 1. 折半查找的定义：折半查找是一种查找算法，它可以在有序表中快速地查找目标元素。该...
C语言实现动态顺序表的实现代码
08-29
主要介绍了C语言实现动态顺序表的实现代码的相关资料,动态顺序表在内存中开辟一块空间，可以随我们数据数量的增多来扩容，需要的朋友可以参考下
数据结构之动态顺序表（附带完整程序）
最新发布
2301_77203593的博客
07-26 758
int age;int height;} Student;//Student类型的数组 int length;//元素的有效个数 int listsize;//最多容纳多少个元素 } SqList;5int age;int height;} Student;//Student类型的数组 int length;//元素的有效个数 int listsize;//最多容纳多少个元素 } SqList;2int age;int height;} Student;
数据结构-动态顺序表的实现（含全部代码）
qq_45967533的博客
03-07 1714
本篇的内容是使用C语言实现一个动态顺序表 文章目录顺序表的概念及结构动态顺序表的接口实现初始化接口销毁接口打印接口检查是否增容接口尾插接口头插接口尾删接口头删接口查找接口在指定位置插入元素接口删除指定位置数据接口修改指定位置元素接口动态顺序表代码 顺序表的概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 我们可以把顺序表理解为一个数组 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。
数据结构中 为什么要用typedef int datatype ，而不直接用int
TwcatL_tree
09-18 1728
用typedef来为类型起个别名，如“typedef long INDEX;”。给long这样的类型起别名主要目的不是简化程序的书写，它有两个用处：一是表明该类型的特殊作用，二是将来有可能要改变这种类型（比如提高精度），如果直接声明为long型则失去了程序的可惟护性——每一个变量的声明都要改动；而声明为INDEX则使维护程序变得十分简单——只要改一下typedef语句即可。 比如 typedef int datetype 然后下面有N个函数 都是类似这样的 datetype typeadd(datetype
【数据结构】之 动态顺序表（C语言）（含完整代码）
weixin_53936115的博客
12-18 1179
顺序表概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下用数组存储。在数组上完成数据的增删查改。 代码解析： 1.准备工作 1.首先对一些头文件的引用和创建一个结构体，结构体包含一个数组，size表示该数组目前有多少个元素，capacity表示目前数组能存多少个元素。例如： #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include&l...
顺序表的C语言实现(静态/动态)
Curz酥的博客
08-20 1446
参考王道数据结构，含图解。
C语言动态实现顺序表
Demons的博客
04-25 588
顺序表的动态存储结构： typedef int DataType; typedef struct SeqListD { DataType* array;//数据指针 size_t capacity; //容量 size_t size; //有效元素的个数 }SeqListD, *PSeqListD; 部分函数操作：   void InitSeqListD(P...
动态顺序表（C语言实现）
cw412524的博客
11-13 764
数据结构动态顺序表（C语言实现），干货满满！
数据结构各章节算法实现（C语言版）.docx
10-12
对于想要提升编程技能、熟悉C语言数据结构的学生来说，这份文档提供了一个实践平台，能够加深对理论知识的理解，提升算法设计和实现能力。在复习备考或解决实际问题时，可以灵活运用这些算法实现，增强自己的编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

谁在夜里看海.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值