数据结构与算法学习笔记二---顺序表的动态存储表示和实现(C语言)

已于 2024-05-24 10:55:11 修改
阅读量300 收藏 5
点赞数 6
分类专栏： C语言专栏 文章标签： 学习 笔记 c语言 数据结构
于 2024-05-13 19:38:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZCC361571217/article/details/138814282
版权

目录

前言

1.顺序表的动态存储过程

1.初始化

2.销毁

3.清空

4.表长

5.取值

6.直接前驱

7.直接后继

8.插入

9.删除  

10.遍历

11.完整代码

2.顺序表操作时间复杂度分析

1.取值

2.查找

3.插入

4.删除

前言

        这篇博客主要是顺序表的动态分配存储表示。

1.顺序表的动态存储过程

        线性表的顺序存储示意图如下：

               图1.线性表的顺序存储示意图

        我们使用静态数据来存储顺序表中的数据元素，静态顺序表定义如下：

//----- 线性表的静态分配顺序存储结构 - - - - -
#define MaxSize 100
typedef int ElementType;
typedef int Status;

typedef struct {
    ElementType data[MaxSize]; // 存储空间基址
    int length;            // 当前长度
}StaticSqList;

1.初始化

        初始化的时候给顺序表动态分配存储空间，设置表长为0.

//初始化
Status initSqList(SqList * sqList){
    sqList->element = (ElementType *)malloc(sizeof(ElementType) * LIST_INIT_SIZE);
    if (!sqList->element) {
        printf("内存分配失败!");
        return 0;
    }
    sqList->length = 0;
    sqList->listSize = LISTINCREMENT;
    return 1;
}

2.销毁

        释放动态分配的存储空间，置空表长和存储空间大小。

// 销毁
void destroySqList(SqList *sqList){
    free(sqList->element);
    sqList->length = 0;
    sqList->listSize = 0;
}

3.清空

        表长置空即可。

// 清空表
void clearSqList(SqList *sqList){
    sqList->length = 0;
}

4.表长

        因为我们在顺序表中定义了表长，直接返回表长即可。

// 表长
int getSqListLength(SqList *sqList){
    return sqList->length;
}

5.取值

        取值操作是根据指定的位置序号i，获取顺序表中第i个数据元素的值。由于顺序存储结构具有随机存取的特点，可以直接通过数组下标定位得到，elem[i-1]单元存储第i个数据元素。

        具体算法：

  1. 判断指定位置是否合法，不合理直接返回0
  2. 位置合法，直接通过下标获取数据元素，然后返回数据元素
Status getElementForSqList(SqList *sqList, int pos, ElementType *element){
    if (pos < 1 || pos > sqList->length) {
        return 0;
    }
    *element = sqList->element[pos - 1];
    return 1;
}

        数据类型(data type)是一个值的集合和定义在这个集合上的一组操作的总称。

6.直接前驱

        遍历顺序表，这里注意的是顺序表中的第一个数据元素没有直接前驱。

// 我这里返回的是数据元素的真实下标,从1开始
Status getSqListLocate(SqList * sqList,ElementType element,int * location){
    for (int i = 0; i < sqList->length; i++) {
        if (sqList->element[i] == element) {//找到数据元素
            * location = i;
            return 1;
        }
    }
    return 0;
}

7.直接后继

         遍历顺序表，这里注意的是顺序表中的最后一个数据元素没有直接后继。

// 获取直接前驱 获取element的前一个数据元素priorElement
Status priorSqListElement(SqList * sqList,ElementType element,ElementType * priorElement){
    for (int i = 0; i<sqList->length; i++) {
        if (sqList->element[i] == element) {//找到数据元素
            if (i>=1) {
                * priorElement = sqList->element[i-1];
                return 1;
            }
        }
    }
    return 0;
}

8.插入

               图2.顺序表插入数据元素示意图

        首先判断要插入的数据元素的位置是否合法，然后判断顺序表是否已满，已满的话需要给顺序表重新分配存储空间。

Status insertSqList(SqList * sqList,int pos,ElementType element){
    if (pos < 1 || pos > sqList->length + 1) {//非法位置
        return 0;
    }
    if (sqList->length >=sqList->listSize ) {//
        ElementType * newElement = (ElementType *)realloc(sqList->element,(sqList->listSize + LISTINCREMENT) * sizeof(ElementType));
        if (!newElement) {
            return 0;
        }
        sqList->listSize+= LISTINCREMENT;
        sqList->element = newElement;
    }
    for (int i = sqList->length; i > pos - 1; i--) {
        sqList->element[i] = sqList->element[i-1];
    }
    sqList->element[pos -1] = element;
    sqList->length++;
    return 1;
}

9.删除  

        

       图3.删除元素示意图

        判断位置是否合法，遍历顺序表。

Status deleteSqList(SqList *sqList,int pos,ElementType * element){
    if (pos < 1 || pos > sqList->length) {
        return 0;
    }
    for (int i = pos - 1; i < sqList->length - 1; i++) {
        sqList->element[i] = sqList->element[i+1];
    }
    * element = sqList->element[pos -1];
    sqList->length--;
    return 1;
}

10.遍历

// 遍历顺序表
void travseSqList(SqList *sqList){
    for (int i = 0; i<sqList->length; i++) {
        printf("%d\t",sqList->element[i]);
    }
    printf("\n");
}

11.完整代码

#include <stdio.h>
#include <stdlib.h>

//----- 线性表的静态分配顺序存储结构 - - - - -
#define LIST_INIT_SIZE  100   // 线性表存储空间的初始分配量
#define LISTINCREMENT 10    // 线性表存储空间的分配增量
typedef int ElementType;
typedef int Status;

typedef struct {
    ElementType *element; // 存储空间的基址
    int length;            // 当前长度
    int listSize;          // 当前存储空间的大小(以sizeof(ElementType)为单位)
} SqList;

//初始化
Status initSqList(SqList *sqList){
    sqList->element = (ElementType *)malloc(sizeof(ElementType) * LIST_INIT_SIZE);
    if (!sqList->element) {
        printf("内存分配失败!\n");
        return 0;
    }
    sqList->length = 0;
    sqList->listSize = LIST_INIT_SIZE;
    return 1;
}

// 销毁
void destroySqList(SqList *sqList){
    free(sqList->element);
    sqList->length = 0;
    sqList->listSize = 0;
}

// 清空表
void clearSqList(SqList *sqList){
    sqList->length = 0;
}

// 表长
int getSqListLength(SqList *sqList){
    return sqList->length;
}

Status sqListIsEmpty(SqList *sqList){
    return sqList->length == 0;
}

Status getElementForSqList(SqList *sqList, int pos, ElementType *element){
    if (pos < 1 || pos > sqList->length) {
        return 0;
    }
    *element = sqList->element[pos - 1];
    return 1;
}

// 我这里返回的是数据元素的真实下标,从0开始
Status getSqListLocate(SqList *sqList, ElementType element, int *location){
    for (int i = 0; i < sqList->length; i++) {
        if (sqList->element[i] == element) {
            *location = i;
            return 1;
        }
    }
    return 0;
}

Status insertSqList(SqList *sqList, int pos, ElementType element){
    if (pos < 1 || pos > sqList->length + 1) {
        return 0;
    }
    if (sqList->length >= sqList->listSize) {
        ElementType *newElement = (ElementType *)realloc(sqList->element, (sqList->listSize + LISTINCREMENT) * sizeof(ElementType));
        if (!newElement) {
            return 0;
        }
        sqList->listSize += LISTINCREMENT;
        sqList->element = newElement;
    }
    for (int i = sqList->length; i > pos - 1; i--) {
        sqList->element[i] = sqList->element[i - 1];
    }
    sqList->element[pos - 1] = element;
    sqList->length++;
    return 1;
}

// 获取直接前驱
Status priorSqListElement(SqList *sqList, ElementType element, ElementType *priorElement){
    for (int i = 0; i < sqList->length; i++) {
        if (sqList->element[i] == element) {
            if (i >= 1) {
                *priorElement = sqList->element[i - 1];
                return 1;
            }
        }
    }
    return 0;
}

// 获取直接后继
Status nextSqListElement(SqList *sqList, ElementType element, ElementType *nextElement){
    for (int i = 0; i < sqList->length; i++) {
        if (sqList->element[i] == element) {
            if (i < sqList->length - 1) {
                *nextElement = sqList->element[i + 1];
                return 1;
            }
        }
    }
    return 0;
}

// 删除
Status deleteSqList(SqList *sqList, int pos, ElementType *element){
    if (pos < 1 || pos > sqList->length) {
        return 0;
    }
    *element = sqList->element[pos - 1];
    for (int i = pos - 1; i < sqList->length - 1; i++) {
        sqList->element[i] = sqList->element[i + 1];
    }
    sqList->length--;
    return 1;
}

// 遍历顺序表
void travseSqList(SqList *sqList){
    for (int i = 0; i < sqList->length; i++) {
        printf("%d\t", sqList->element[i]);
    }
    printf("\n");
}

void commonSqListPrint(const char *string){
    printf("\n**********\t%s测试\t**********\n", string);
}

//测试顺序表的方法
void testSqList(void){
    SqList sqList;
    commonSqListPrint("顺序表的静态存储表示");
    if (initSqList(&sqList)) {
        printf("顺序表初始化成功\n");
    }
    commonSqListPrint("判断顺序表是否为空");
    if (sqListIsEmpty(&sqList)) {
        printf("顺序表为空, 顺序的长度:%d\n", getSqListLength(&sqList));
    }

    commonSqListPrint("顺序表批量插入测试");
    for (int i = 1; i <= 5; i++) {
        if (insertSqList(&sqList, i, i)) {
            printf("数据元素%d插入成功!\n", i);
        } else {
            printf("数据插入失败!\n");
        }
    }

    printf("插入之后的数组为:\n");
    travseSqList(&sqList);

    commonSqListPrint("单个数据元素插入");

    if (insertSqList(&sqList, 5, 11)) {
        printf("数据元素插入成功\n");
    } else {
        printf("插入失败\n");
    }
    printf("插入之后的数组:\n");
    travseSqList(&sqList);

    commonSqListPrint("顺序表表长:");
    printf("顺序的长度:%d\n", getSqListLength(&sqList));

    commonSqListPrint("顺序表删除");
    int deleteElement;
    if (deleteSqList(&sqList, 5, &deleteElement)) {
        printf("数据元素%d删除成功\n", deleteElement);
    } else {
        printf("删除失败\n");
    }

    printf("删除之后的顺序表:\n");
    travseSqList(&sqList);

    commonSqListPrint("获取顺序表中的数据元素");
    for (int i = 0; i <= 11; i++) {
        int location;
        if (getSqListLocate(&sqList, i, &location)) {
            printf("数据元素%d的下标获取成功, 数据元素下标为:%d\n", i, location);
        } else {
            printf("第%d个数据元素下标获取失败\n", i);
        }
    }

    commonSqListPrint("顺序表直接前驱");
    for (int i = 1; i <= sqList.length; i++) {
        ElementType priorElem;
        if (priorSqListElement(&sqList, i, &priorElem)) {
            printf("数据元素%d存在, 直接前驱为:%d\n", i, priorElem);
        } else {
            printf("数据元素%d存在, 直接前驱不存在\n", i);
        }
    }

    commonSqListPrint("顺序表直接后继");
    for (int i = 1; i <= sqList.length; i++) {
        ElementType nextElem;
        if (nextSqListElement(&sqList, i, &nextElem)) {
            printf("数据元素%d存在, 直接后继为:%d\n", i, nextElem);
        } else {
            printf("数据元素%d存在, 直接后继不存在\n", i);
        }
    }

    commonSqListPrint("顺序表销毁测试");
    destroySqList(&sqList);
    printf("顺序表已销毁\n");
}

int main(int argc, const char *argv[]) {
    testSqList();
    return 0;
}

2.顺序表操作时间复杂度分析

1.取值

        顺序表取值的时候，时间复杂度为O(1)。

2.查找

        当在顺序表中查找一个数据元素时，其时间主要耗费在数据的比较上，而比较的次数取决于被查元素在线性表中的位置。
        在查找时，为确定元素在顺序表中的位置，需和给定值进行比较的数据元素个数的期望值称为查找算法在查找成功时的平均查找长度(Average Search Length，ASL)。
        假设p是查找第1个元素的概率，C为找到表中其关键字与给定值相等的第i个记录时，和给定值已进行过比较的关键字个数，则在长度为n的线性表中，查找成功时的平均查找长度为：

        图4.平均查找长度

        从顺序表查找的过程可见，C;取决于所查元素在表中的位置。例如，查找表中第一个记录时，仅需比较一次;而查找表中最后一个记录时，则需比较n次。一般情况下C等于i。
        假设每个元素的查找概率相等，即P(i)=1/n

图5.平均查找时间复杂度

3.插入

        当在顺序表中某个位置上插入一个数据元素时，其时间主要耗费在移动元素上，而移动元素的个数取决于插入元素的位置。
        假设p是在第1个元素之前插入一个元素的概率，与为在长度为n的线性表中插入一个元素时所需移动元素次数的期望值(平均次数)，则有

图6.移动数据元素的平均次数

4.删除

        当在顺序表中某个位置上删除一个数据元素时，其时间主要耗费在移动元素上，而移动元素的个数取决于删除元素的位置。
        假设p是删除第i个元素的概率，E为在长度为n的线性表中删除一个元素时所需移动元素次数的期望值(平均次数)，则有

        假设在线性表的任何位置上删除元素的概率都是等概率的，则

        P(i) = 1/n;

我叫柱子哥
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
顺序表的动态存储
chenjunshuo的博客
01-24 2001
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般分为： 1.静态顺序表：使用定长的数组存储； 2.动态顺序表：使用动态开辟的数组存储； 由于静态顺序表相对简单，我们便以动态顺序表为例来实现顺序表的相关接口； 首先是顺序表结构体的定义： 一般来说顺序表的结构体中主要包含：用于存储数据的数组，用于记录末尾数据下标（还能...
顺序表动态存储
weixin_52381486的博客
07-13 136
#include<stdio.h> #include<stdlib.h> #define InitSize 10 typedef struct{ float *data; int length; int MaxSize; //顺序表最大容量 }seqList; void initSeL(seqList &L){ L.data = static_cast<float*>(malloc(InitSize * sizeof(f...
【数据结构】顺序表的动态存储
weixin_45902047的博客
03-03 234
SeqList.h #include"SList.h" void TestSList() { //SListNode phead;//直接定义一个头节点？ //此时只需要一个指针即可，不需要结点！！！！ SListNode* pList = NULL;//因为头指针只有指针域没有数据域，这里只需要一个指针变量即可 SListPrint(pList); SListPushBack(&pList, 1); SListPushBack(&pList, 1); SListPushB
顺序表-动态存储（C语言）
qq_41607217的博客
03-16 400
线性表-动态分配 Status initList_Sq(&L); 初始化操作 Status ListInsert_Sq(&L,i,b); 插入操作 ElemType GetElem(&L,i); 按位取元素 ElemType ListDelete(&L,i); 删除 Sq_List MergeList_Sq(&La,&Lb); 合并两个线性表 Status Sort(); 线性表排序 SqList.h 源码 /* *项目名: List *文件名: SqLis
算法数据结构学习笔记-C语言.zip
最新发布
06-16
总结来说，"算法数据结构学习笔记-C语言.zip"这个资源包旨在帮助学习者掌握数据结构和算法的基础知识，通过C语言实现，增强对底层机制的理解，同时提供实践机会，提升编程和问题解决能力。这份资料对于大学生，尤其...
小甲鱼C-C语言描述数据结构 笔记.pdf
11-17
数据结构和C语言是计算机科学...通过学习小甲鱼的C语言数据结构课程，你可以深入理解如何利用C语言实现各种数据结构，并掌握评估和优化算法效率的方法。这不仅有助于提升编程技能，也是成为一名优秀程序员的关键步骤。
C++ 数据结构——顺序表的动态存储
qq_45875966的博客
03-24 157
/* 顺序表的动态存储 */ #include <iostream> using namespace std; const int InitSize=100; const int IncreSize=10; template<typename T> class SeqList { private: int length; T* data; int maxSize; public: SeqList(); SeqList(T a[],int n
C语言简易顺序表(动态内存)
Obto_的博客
05-30 256
简易版 顺序表(一看就会)
【数据结构】 动态存储的顺序表
Suk_god的博客
11-24 1127
文章目录顺序表的概念及结构分类1. 静态顺序表：使用定长数组存储元素。2.动态顺序表：使用动态开辟的数组存储。相关接口的实现动态开辟空间相关函数操作申明相关代码分享思考与总结1.顺序表的任意位置插入，时间复杂度高2.扩容消耗大3.扩容标准问题如何解决？ 顺序表的概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 分类 1. 静态顺序表：使用定长数组存储元素。 不常用，也不实用。需要根据情况提前确定容量。 2.动态顺序表：使用动态开
顺序存储【C语言动态顺序表】
qq_53772930的博客
04-03 823
C语言实现顺序存储的顺序表（多动图分析）
顺序表的动态存储细节
Bing's Blog
12-03 2080
顺序表的动态存储细节@(算法学习) 在顺序表的动态存储定义中需要包含的数据成员是（C） I. 数组指针 II. 表中元素个数n III. 表的大小maxSize IV. 数组基址base A. I 、II B. I 、II、IV C. I 、II、III D. 全部如果是在代码中写顺序表的动态存储方式，可能上手就知道要定义一个可动态增长的数组，通过malloc或者n
顺序表（动态存储）的基本操作
gaokuiyuan的博客
07-23 394
顺序表的动态分配，main函数采用接口输出实现。
动态顺序表
XHfight的博客
06-01 722
一、动态顺序表：        动态顺序表也是顺序表，不过它是动态的，也就是说它的容量是可以改变的，这就克服了静态顺序表容量不能改变的缺点。当顺序表的容量存满以后，我们可以对它进行扩容，概念就简单介绍到这里了。 二、动态顺序表的数据结构： typedef struct SeqList_D { DataType* array; //指向数据块的指针 size_t size
顺序表的动态存储基本接口实现
lexiaoyao_0000的博客
07-18 106
静态顺序表只适用于确定需要存多少数据的场景。 静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。 所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以，下面我们实现动态顺序表。 函数声明： #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include<stdio.h> #include<stdlib....
数据结构--动态储存顺序表(含完整代码)
qq_65641647的博客
11-03 938
动态顺序表详解，内含完整代码实现。
【数据结构】实现动态顺序表及详细讲解
Eraser的博客
05-04 651
数据结构的常见线性表，分别是顺序表，链表，栈，队列 本篇给大家带来动态顺序表的实现和讲解
顺序表的存储结构（动态）
木辛木又
01-17 8173
顺序表的存储结构（动态） 在建立顺序表时，除了预先申请内存空间，还需要实时记录顺序表的长度和顺序表本身申请的内存大小，便于后期对顺序表中的数据元素进行调取。 所以，要自定义顺序表的结构： 顺序表的创建 顺序表的建立，也就是顺序表进行初始化，在预先申请内存空间的同时，给变量size和length赋初值： 顺序表查找元素 在数组中查找某个数据元素时，可以采取多种查找算法，例如二分查找、插值查找、斐...
数据结构与算法学习笔记：线性表和顺序存储
"数据结构与算法的学习笔记，包含基本数据结构的概念、代码实现及图片，但笔记格式不美观。" 本文将深入探讨数据结构与算法的相关知识，首先，我们要理解数据结构这一概念。数据结构是一门研究非数值计算中数据元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我叫柱子哥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值