数据结构·一篇搞定顺序表！

最新推荐文章于 2024-06-11 19:36:10 发布
最新推荐文章于 2024-06-11 19:36:10 发布
阅读量1k 收藏 24
点赞数 24
文章标签： 数据结构 c语言 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80357424/article/details/137961928
版权

大家好啊，几日不见，甚是想念，从这一篇文章开始，我们就要进入数据结构了哦，那么我们废话不多说，今天我们一起来搞定顺序表！！！
请添加图片描述

1. 顺序表概念及结构

顺序表是一种线性结构，它由一组连续的存储单元（通常是数组）组成，数据元素之间的关系是相邻的。顺序表中的元素是按照一定的顺序排列的，可以通过下标来访问和操作各个元素。顺序表的结构简单、易于实现，是一种常见的数据结构之一。

2. 顺序表分类

• 顺序表和数组的区别
◦ 顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接口

静态顺序表

#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int length;
} StaticList;

在这个例子中，我们定义了一个包含10个整数元素的静态顺序表，其中data数组存储元素，length表示当前顺序表中元素的个数。在使用静态顺序表时，需要注意不要超出预先定义的最大长度，否则可能导致数组越界错误.

动态顺序表

在这里插入图片描述
我们一般使用顺序表都是动态顺序表，这样的话才可以进行增删改查的操作，那么我们接下来就来康康这些操作~

3. 实现动态顺序表

#define INIT_CAPACITY 4
typedef int SLDataType;
// 动态顺序表 -- 按需申请
typedef struct SeqList
{
 SLDataType* a;
 int size; // 有效数据个数
 int capacity; // 空间容量
}SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);
//扩容
void SLCheckCapacity(SL* ps);
//头部插⼊删除 / 尾部插⼊删除
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);
//指定位置之前插⼊/删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);

下面是实现的代码

#define INIT_CAPACITY 4  
  
typedef int SLDataType;  
  
typedef struct SeqList {  
    SLDataType* a;  
    int size; // 有效数据个数  
    int capacity; // 空间容量  
} SL;

3.1 初始化

// 初始化  
void SLInit(SL* ps) {  
    ps->a = (SLDataType*)malloc(INIT_CAPACITY * sizeof(SLDataType));  
    if (!ps->a) {  
        exit(EXIT_FAILURE); // 分配内存失败  
    }  
    ps->size = 0;  
    ps->capacity = INIT_CAPACITY;  
}
  1. 通过 malloc 函数为顺序线性表的数组成员 a 分配内存空间，大小为 INIT_CAPACITY *
    sizeof(SLDataType)，其中 INIT_CAPACITY 是一个预先定义的常量，表示初始容量。
  2. 检查内存分配是否成功，如果分配失败（即 ps->a 为 NULL），则调用 exit(EXIT_FAILURE)
    函数退出程序。
  3. 将顺序线性表的 size 成员初始化为 0，表示当前表中没有元素。
  4. 将顺序线性表的 capacity 成员初始化为INIT_CAPACITY，表示表的初始容量为 INIT_CAPACITY。

3.2 销毁

void SLDestroy(SL* ps) {  
    free(ps->a);  
    ps->a = NULL;  
    ps->size = 0;  
    ps->capacity = 0;  
}
  1. 调用 free 函数释放顺序线性表的数组成员 a 所占用的内存空间，这样可以避免内存泄漏。
  2. 将顺序线性表的 a 成员指针设置为 NULL，这是一种良好的习惯，可以避免出现野指针访问的问题。
  3. 将顺序线性表的 size 成员设为 0，表示表中不再有元素。
  4. 将顺序线性表的 capacity 成员设为 0，表示表的容量为 0。

3.3 打印

void SLPrint(SL* ps) {  
    for (int i = 0; i < ps->size; i++) {  
        printf("%d ", ps->a[i]);  
    }  
    printf("\n");  
}

这个没什么好说的吧哈哈哈

3.4 扩容

void SLCheckCapacity(SL* ps) {  
    if (ps->size == ps->capacity) {  
        ps->capacity *= 2;  
        SLDataType* temp = (SLDataType*)realloc(ps->a, ps->capacity * sizeof(SLDataType));  
        if (!temp) {  
            exit(EXIT_FAILURE); // 扩容失败  
        }  
        ps->a = temp;  
    }  
}
  1. 判断顺序线性表的当前大小（size）是否等于容量（capacity），如果相等，则表示表中元素已经填满，需要进行扩容操作。
  2. 将顺序线性表的容量 capacity 扩大为原来的两倍，即 ps->capacity *= 2;，这里采用了简单的扩容策略。
  3. 调用 realloc 函数重新分配内存空间，将原来的数据拷贝到新的空间中，大小为 ps->capacity *
    sizeof(SLDataType)。
  4. 检查是否成功分配新的内存空间，如果分配失败（即 temp 为 NULL），则调用 exit(EXIT_FAILURE)
    函数退出程序。
  5. 将新分配的内存空间的地址赋值给顺序线性表的数组成员 a，完成扩容操作。

3.5 头部插入

void SLPushFront(SL* ps, SLDataType x) {  
    SLCheckCapacity(ps);  
    for (int i = ps->size; i > 0; i--) {  
        ps->a[i] = ps->a[i - 1];  
    }  
    ps->a[0] = x;  
    ps->size++;  
}
  1. 调用 SLCheckCapacity 函数，确保顺序线性表有足够的容量来存储新的元素。
  2. 从顺序线性表的最后一个元素开始，依次将元素向后移动一个位置，为新元素腾出空间。这里使用循环从 ps->size
    开始，依次向前移动元素，直到第一个元素。
  3. 将要插入的新元素 x 放入顺序线性表的第一个位置，即头部位置。
  4. 增加顺序线性表的大小 size，表示表中元素数量增加了一个。

3.6 头部删除

void SLPopFront(SL* ps) {  
    if (ps->size == 0) {  
        return;  
    }  
    for (int i = 0; i < ps->size - 1; i++) {  
        ps->a[i] = ps->a[i + 1];  
    }  
    ps->size--;  
}
  1. 判断顺序线性表的大小（size）是否为0，如果是空表（size == 0），则直接返回，不进行删除操作。
  2. 从顺序线性表的第一个元素开始，依次将元素向前移动一个位置，覆盖掉原来的元素。这里使用循环从0开始，依次向后移动元素，直到倒数第二个元素。
  3. 减少顺序线性表的大小 size，表示表中元素数量减少了一个。

3.7 尾部插入

void SLPushBack(SL* ps, SLDataType x) {  
    SLCheckCapacity(ps);  
    ps->a[ps->size] = x;  
    ps->size++;  
}
  1. 调用 SLCheckCapacity 函数，确保顺序线性表有足够的容量来存储新的元素。
  2. 将要插入的新元素 x 放入顺序线性表当前大小（size）的位置，即在尾部插入。
  3. 增加顺序线性表的大小 size，表示表中元素数量增加了一个。

3.8 尾部删除

不用说吧~~~

void SLPopBack(SL* ps) {  
    if (ps->size == 0) {  
        return;  
    }  
    ps->size--;  
}

3.9 指定位置之前插入数据

void SLInsert(SL* ps, int pos, SLDataType x) {  
    if (pos < 0 || pos > ps->size) {  
        return; // 插入位置不合理  
    }  
    SLCheckCapacity(ps);  
    for (int i = ps->size; i > pos; i--) {  
        ps->a[i] = ps->a[i - 1];  
    }  
    ps->a[pos] = x;  
    ps->size++;  
}
  1. 判断插入位置 pos 是否合理，即必须满足 pos >= 0 且 pos <= ps->size，否则直接返回，不进行插入操作。
  2. 调用 SLCheckCapacity 函数，确保顺序线性表有足够的容量来存储新的元素。
  3. 从顺序线性表的最后一个元素开始，依次将元素向后移动一个位置，为新元素腾出空间。这里使用循环从 ps->size开始，依次向前移动元素，直到插入位置 pos。
  4. 将要插入的新元素 x 放入顺序线性表的指定位置 pos。
  5. 增加顺序线性表的大小 size，表示表中元素数量增加了一个.

3.10 指定位置删除数据

void SLErase(SL* ps, int pos) {  
    if (pos < 0 || pos >= ps->size) {  
        return; // 删除位置不合理  
    }  
    for (int i = pos; i < ps->size - 1; i++) {  
        ps->a[i] = ps->a[i + 1];  
    }  
    ps->size--;  
}
  1. 判断删除位置 pos 是否合理，即必须满足 pos >= 0 且 pos < ps->size，否则直接返回，不进行删除操作。
  2. 从指定位置 pos 开始，将后面的元素依次向前移动一个位置，覆盖掉要删除的元素。这里使用循环从 pos
    开始，依次将元素向前移动，直到倒数第二个元素。
  3. 减少顺序线性表的大小 size，表示表中元素数量减少了一个，相当于删除了一个元素。

3.11 查找数据

int SLFind(SL* ps, SLDataType x) {  
    for (int i = 0; i < ps->size; i++) {  
        if (ps->a[i] == x) {  
            return i; // 返回数据下标  
        }  
    }  
    return -1; // 没有找到数据  
}

4. 基于动态顺序表实现通讯录项目

相信大家掌握了上面的操作后，实现通讯录并不是啥难事，肖恩在这也不细细讲解了，希望大家理解哦~~~请添加图片描述

由于这个通讯录的代码有一点点多，放在这里大家也不好学习，我直接放个链接吧，大家直接点开就欧克了，也方便copy.
通讯录

5. 顺序表经典算法

这是两个有关顺序表的经典的算法的，大家点开链接可以做做，同样，我把代码放在这，大家自行悟道
经典算法OJ题1： 移除元素

int removeElement(int* nums, int numsSize, int val) {
        int i, j;
    for(i = 0, j = 0; i < numsSize; i++){
        if(nums[i] != val){
            nums[j] = nums[i];
            j++;
        }
    }
    return j;
}

经典算法OJ题2： 合并两个有序数组

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
int p1 = m - 1;
    int p2 = n - 1;
    int p = m + n - 1;
    
    while(p1 >= 0 && p2 >= 0){
        if(nums1[p1] > nums2[p2]){
            nums1[p] = nums1[p1];
            p1--;
        } else {
            nums1[p] = nums2[p2];
            p2--;
        }
        p--;
    }
    
    while(p2 >= 0){
        nums1[p] = nums2[p2];
        p2--;
        p--;
    }
}

大家要是有比这个好的方法那就更好了！还是比肖恩强的哈哈哈

6. 顺序表的问题及思考*

  1. 中间/头部的插入删除，时间复杂度为O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

思考：如何解决以上问题呢？

在这里插入图片描述
下期预告
那当然是…Linked List

Sheep Shaun
关注
  • 24
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
【数据结构】动态顺序表的实现（附带详细注释）
weixin_65334260的博客
07-15 1260
顺序表是指用一组地址连续的存储单元依次存储线性表数据元素的存储结构。由于存储单元的地址要连续，故想到可以使用数组来实现顺序表，数组又分为动态数组和静态数组，本篇展示使用动态一维数组实现顺序表以及实现对顺序表的各种操作。......
数据结构基础概念篇
热门推荐
小草莓的博客
11-14 31万+
数据结构一些概念 数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。数据：所有能被输入到计算机中，且能被计算机处理的符号的集合。是计算机操作的对象的总称。 数据元素：数据（集合）中的一个“个体”，数据及结构中讨论的基本单位 数据项：数据的不可分割的最小单位。一个数据元素可由若干个数据项组成。 数据类
来吧！一文彻底搞定哈希表！
庆哥Java的CSDN技术博客
12-02 15万+
哈希表是个啥？ 小白： 庆哥，什么是哈希表？这个哈希好熟悉，记得好像有HashMap和HashTable之类的吧，这是一样的嘛？???? 庆哥： 这个哈希确实经常见????，足以说明它是个使用非常频繁的玩意儿，而且像你说的HashMap和HashTable之类的与哈希这个词肯定是有关系的，那哈希是个啥玩意啊，这个咱们还是得先来搞明白啥是个哈希表。???? 我们看看百科解释吧： 散列表（Hash table，也叫哈...
【数据结构】顺序表：与时俱进的结构解析与创新应用
Miracle_86的博客
04-21 3576
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构反映数据的内部构成，即数据由哪部分构成，以什么方式构成，以及数据之间存在的相互关系。 | 数据结构 | 顺序表 |
算法与数据结构入门一篇就搞定
理想二旬不止 - 专注JAVA技术
09-19 1503
算法与数据结构开篇 你真的会数据结构吗？ 公司开发一个客服电话系统，小菜需要完成客户排队模块的开发，经过三次修改： 第一次：小菜使用了数据库设计了一张客户排队表，并且设置了一个自动增长的整型id字段，来一个用户，就在这张表的末尾插入一条数据，等客服系统一空闲，就将表中最前的的客户提交，然后删除这条记录。 实时排队模块，在内存中实现即可，无序用数据库 第二次：小菜用数组变量重新实现了这个功能...
初级数据结构（二）——链表
Peeepi的博客
12-07 2105
顺序表的劣势在于，开辟空间并非随需开辟，释放空间也显得不那么灵活。如果顺序表做到每次增加数据便拓展空间，删除数据便回收空间，基于 realloc 可能异地开辟的特点，搬运数据的时间复杂度为 O(N) 。如果顺序表的长度是几千万乃至几亿，每添加或者删除一个数据，其延迟是难以忽略的。如果有一种储存方式可以解决上述问题，做到每一个数据的空间都按需开辟，且按需释放，那么在最极端的情况下，它甚至可以节省近一半存储空间。
【C语言回顾】指针（超详细！！一篇文章搞定！！！）
2302_80269373的博客
05-04 1661
各位小伙伴大家好！今日天有晴，阳光灿烂;今日地有情，花团锦簇;今日海有情，浪迭千重;今日人有情，欢聚一堂!指针是C语言的灵魂，同时也是大多数人的噩梦。不懂指针，相当于没学C语言。上期小编给大家讲解了C语言中的操作符，接下来我们好好地细说指针！以上就是小编对指针的详细讲解。如果觉得小编讲的还可以，还请一键三连。互三必回！持续更新中~！我一直在遇见许多不同的、可爱的、善良的人，继而又不舍的与他们分别。能脚踏实地，也仰望星空；既有随处可栖的江湖，也有追风逐梦的骁勇。
数据结构与算法解析 -- 链表篇
Eureka1024的博客
06-13 1568
**2020-6-13 ** 从来如此，便对吗？ – 鲁迅《狂人日记》 一、概述 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域（对于双向链表也会存储上一个节点的地址域）。 常见的三种链表结构： 单链表 双向链表 循环链表 双向循环链表 二、链表的结构形式分析 2.1、单链表 链表.
【数据结构与算法】使用顺序表删除线性表中所有值为item的数据元素
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
03-17 1763
用数组实现顺序表中删除线性表中所有值为item的数据元素的算法（双指针版）
PTA—C语言数据结构：顺序表.ppt
10-11
PTA平台数据结构课程顺序表参考答案
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍： 顺序表是一种线性表，...
数据结构与算法-顺序表（链表篇）
09-09
代码资源
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
maniuT的博客
06-11 1040
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 315
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
数据结构--线性表和串
code袁的博客
06-08 815
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896线性表是一种常见的数据结构，它是具有相同数据类型的有限序列。线性表中的元素之间存在一种顺序关系，可以通过元素在表中的位置来访问和操作。串是由零个或多个字符组成的有限序列，也可以理解为字符串。串是计算机科学中最基本的数据类型之一，常用于表示文本信息。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构 -- 树状数组
gghhb12的博客
06-09 1253
树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。具体区别和联系如下：1.两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度也远小于线段树.
【算法与数据结构】【数组篇】【题6-题10】
最新发布
handsomethefirst的博客
06-11 1169
首先，是一个递增排序，那么我们可以知道头尾相加，判断最大值和最小值的和是否等于目标值，如果大于目标值，则说明我们值找大了，那就要找到次第二最大值，作为新区间的最大值，然后继续判断是否等于目标值。当为偶数的时候，如果x+y=i，i的值小于最大的行数，代表坐标x从i开始，y从0开始，如果i大于等于最大的行数，代表坐标x从m开始，y=i-m开始。当为奇数的时候，如果x+y=i，i的值小于最大的列数，代表坐标y从i开始，x从0开始, 如果i大于等于最大的列数，代表坐标y从n开始，x=i-n开始。
牛客网刷题 | BC117 逆序输出
m0_64000959的博客
06-09 550
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入10个整数，要求按输入时的逆序把这10个数打印出来。逆序输出，就是按照输入相反的顺序打印这10个数。一行，输入10个整数（范围-231~231-1），用空格分隔。一行，逆序输出输入的10个整数，用空格分隔。使用数组的方法将用户输入的数字存起来然后使用数组将它打印出来 自减的方式 代码 2 ：
数据结构：构造一个顺序表
05-24
顺序表是一种基于数组的数据结构，可以存储一组连续的元素。下面是构造一个顺序表的示例代码： ```c #define MAXSIZE 100 // 定义顺序表最大长度 typedef struct { int data[MAXSIZE]; // 存储数据的数组 int length; // 当前长度 } SqList; // 初始化顺序表 void InitList(SqList *L) { L->length = 0; } // 插入元素 int InsertList(SqList *L, int pos, int elem) { if (pos < 1 || pos > L->length + 1 || L->length >= MAXSIZE) { return 0; // 插入位置不合法或者顺序表已满，插入失败 } for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1]; // 将pos及之后的元素后移 } L->data[pos - 1] = elem; // 插入新元素 L->length++; // 长度加1 return 1; // 插入成功 } // 删除元素 int DeleteList(SqList *L, int pos) { if (pos < 1 || pos > L->length) { return 0; // 删除位置不合法，删除失败 } for (int i = pos; i < L->length; i++) { L->data[i - 1] = L->data[i]; // 将pos及之后的元素前移 } L->length--; // 长度减1 return 1; // 删除成功 } // 查找元素 int FindList(SqList *L, int elem) { for (int i = 0; i < L->length; i++) { if (L->data[i] == elem) { return i + 1; // 返回元素在顺序表中的位置 } } return 0; // 未找到元素 } // 输出顺序表 void PrintList(SqList *L) { for (int i = 0; i < L->length; i++) { printf("%d ", L->data[i]); } printf("\n"); } ``` 这里定义了一个 `SqList` 结构体，其中 `data` 是存储数据的数组，`length` 是当前长度。`InitList` 函数用于初始化顺序表，将长度设为0。`InsertList` 函数用于在指定位置插入元素，如果位置不合法或者顺序表已满，返回0表示插入失败；否则将插入位置及之后的元素后移，插入新元素，长度加1，返回1表示插入成功。`DeleteList` 函数用于删除指定位置的元素，如果位置不合法，返回0表示删除失败；否则将删除位置及之后的元素前移，长度减1，返回1表示删除成功。`FindList` 函数用于查找指定元素在顺序表中的位置，如果未找到，返回0表示未找到。`PrintList` 函数用于输出顺序表中的所有元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值