数据结构（顺序表）

#define N 7 //方便后期修改成其他数字大小,一键替换
typedef int SLDataType; //方便后期修改成其他类型,一键替换
typedef struct SeqList
{
SLDataType a[N];//定长数组
int size;//有效的数据个数
}SL;//把struct SeqList结构体重命名为SL

动态顺序表

1. 结构体成员变量声明时不能初始化。（但可以宏定义）

typedef int SLDataType;//方便后期修改成其他类型,一键替换
typedef struct SeqList
{
SLDataType* arr;
    int capacity;//顺序表的容量
int size;//有效数据大小
}SL;//把struct SeqList结构体重命名为SL

动态顺序表的初始化

1. 不能直接传值给形参来实现初始化。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
typedef int SLDataType;
typedef struct SeqList
{
SLDataType* arr;
int size;
int capacity;
}SL;
void test(SL s)
{
s.arr = NULL;
s.size = s.capacity = 0;
return 0;
}
int main()
{
SL s1;
test(s1);//由于传值，所以函数调用完后，形参空间释放，实参无影响，故还是没有初始化
return 0;
}

2. 可以通过传地址给形参来实现初始化。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
typedef int SLDataType;
typedef struct SeqList
{
SLDataType* arr;
int size;
int capacity;
}SL;
void test(SL* ps)
{
ps->arr = NULL;
ps->size = ps->capacity = 0;
return 0;
}
int main()
{
SL s1;
test(&s1);
return 0;
}
//ps->相当于*(p.s)

如果直接传值，那么结构体变量s1将无法初始化，因为形参初始化完后，就直接释放了内存空间。

如果传地址的话，那么形参和实参共用一块地址，所以结构体变量s1就能实现初始化。

动态顺序表的销毁

void test2(SL* ps)
{
if (ps->arr!=NULL)//如果arr不是NULL，则进入
{
free(ps->arr);//释放空间
}
ps->arr = NULL;
ps->size = ps->capacity = 0;
return 0;
}

顺序表的销毁与初始化很像，多了一个操作：如果结构体变量s1占用了内存，那么先释放内存，再将结构体变量s1初始化。

动态顺序表的增容

1. 增容一般成倍数增容，一般2倍或者3倍。

void test3(SL* ps)
{
    assert(ps);//防止传入空指针
if (ps->size== ps->capacity)//判断后面是否还有剩余空间,如果没有则进入扩容
{
int NEWcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//防止capacity为0
SLDataType* tem = (SLDataType*)relloc(ps->arr, NEWcapacity  * sizeof(SLDataType);
if (tem == NULL)//判断是否扩容失败，如果失败则进入退出程序
{
perror("relloc fail");//显示增容错误
exit(1);//退出程序
}
ps->arr = tem;
ps->capacity = NEWcapacity;//更新成员内容
}
return 0;
}

动态顺序表尾插数据

void test3(SL* ps, SLDataType x)
{
assert(ps);//防止传入空指针
if (ps->size== ps->capacity)//判断后面是否还有剩余空间,如果没有则进入扩容
{
int NEWcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SLDataType* tem = (SLDataType*)relloc(ps->arr, NEWcapacity  * sizeof(SLDataType);
if (tem == NULL)//判断是否扩容失败，如果失败则进入退出程序
{
perror("relloc fail");//显示增容错误
exit(1);//退出程序
}
ps->arr = tem;
ps->capacity = NEWcapacity;
}
ps->arr[ps->size++] = x;//尾部插入
return 0;
}

动态顺序表头插数据

void test3(SL* ps, SLDataType x)
{
assert(ps);//防止传入空指针
if (ps->size == ps->capacity)//判断后面是否还有剩余空间,如果没有则进入扩容
{
int NEWcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SLDataType* tem = (SLDataType*)relloc(ps->arr, NEWcapacity * sizeof(SLDataType);
if (tem == NULL)//判断是否扩容失败，如果失败则进入退出程序
{
perror("relloc fail");//显示增容错误
exit(1);//退出程序
}
ps->arr = tem;
ps->capacity = NEWcapacity;
}
for (int i = ps->size;i>0; i--)
{
ps->arr[i] = ps->arr[i - 1];
}
    ps->arr[0]=x;
return 0;
}

动态顺序表尾删数据

void test5(SL* ps)
{
assert(ps);//防止传入空指针，不能进行解引用
assert(ps->size);//防止没有有效数据
ps->size--;//有效成员个数减一
return 0;
}

动态顺序表头删数据

void test6(SL* ps)
{
assert(ps);
assert(ps->size);
for (int i = 1; i < ps->size-1; i++)//除了第一个数组成员，其余的都往前移一位
{
ps->arr[i - 1] = ps->arr[i];
}
ps->size--;//有效成员个数减一
return 0;
}

动态顺序表任意位置增加数据

void test7(SL* ps,int pos, SLDataType x)
{
assert(ps);
assert(pos > 0 && pos < ps->size);
if (ps->size == ps->capacity)//判断后面是否还有剩余空间,如果没有则进入扩容
{
int NEWcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SLDataType* tem = (SLDataType*)relloc(ps->arr, NEWcapacity * sizeof(SLDataType);
if (tem == NULL)//判断是否扩容失败，如果失败则进入退出程序
{
perror("relloc fail");//显示增容错误
exit(1);//退出程序
}
ps->arr = tem;
ps->capacity = NEWcapacity;
}
for (int i = ps->size; i>pos; i--)
{
ps->arr[i] = ps->arr[i - 1];
}
ps->arr[pos] = x;
ps->size++;
return 0;
}

动态顺序表任意位置删除数据

void test7(SL* ps, int pos, SLDataType x)
{
assert(ps);
assert(pos > 0 && pos < ps->size);
for (int i = pos; i < ps->size-1; i++)
{
ps->arr[i] = ps->arr[i + 1];
}
ps->size--;
return 0;
}

动态顺序表的成员查找

int test8(SL* ps,SLDataType x)
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
if (ps->arr[ps->size] == x)
{
printf("找到了");
return x;
}
}
return -1;//如果没有找到则返回一个无效的下标
}

致谢

感谢您花时间阅读这篇文章！如果您对本文有任何疑问、建议或是想要分享您的看法，请不要犹豫，在评论区留下您的宝贵意见。每一次互动都是我前进的动力，您的支持是我最大的鼓励。期待与您的交流，让我们共同成长，探索技术世界的无限可能！

原文地址：https://blog.csdn.net/hsy1603914691/article/details/142280812

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【Qt】编写第一个Qt程序 && 对象树 && 内存泄漏问题探讨
下一篇：什么是算力？cpu+显卡吗？

恋爱辅助应用小程序app开发之广告策略
恋爱话术小程序带流量主广告开启，是一个有效的盈利模式，可以增加小程序的收入来源。以下是对此的详细分析。：根据小程序的特点和目标用户群体，选择合适的广告类型（如横幅广告、插屏广告、视频广告等）。：合理的
阅读更多2024-09-30
Vue.js与Flask/Django后端的协同开发研究
前后端分离是指将客户端（前端）和服务器端（后端）进行逻辑上的分离。前端使用现代JavaScript框架（如Vue.js、React、Angular等）进行用户界面开发，后端则使用如Node.js、Fl
阅读更多2024-09-30
【HTML5】html5开篇基础（5）
选择控件按钮控件 input标签常用属性下面是一个使用的示例：在这个例子中，点击"请输入用户名："文本会使元素获得焦点。
阅读更多2024-09-30
2024大二上js高级+ES6学习9.26（闭包，递归函数）
9.26.2024。
阅读更多2024-09-30
华为eNSP：端口隔离
端口隔离是一种网络配置技术，用于将不同的网络设备或用户隔离在不同的虚拟局域网（VLAN）中，以实现网络流量的隔离和安全性提升。通过在交换机或路由器上配置端口隔离，可以将连接到同一设备的端口分配到不同的
阅读更多2024-09-30
脚本自动化创建AWS EC2实例+安装ElasticSearch和Kibana+集成OpenTelemetry监控
所有服务器部署流程使用同一个部署脚本来保证部署流程标准化每个服务器的server.properties和user-data.txt不一样，每次部署只需要提供这两个文件即可对于部署之后的验证也可写成脚本
阅读更多2024-09-30
JAVA并发编程高级——JDK 新增的原子操作类 LongAdder
既然 AtomicLong的性能瓶颈是由于过多线程同时去竞争一个变量的更新而产生的，那么如果把一个变量分解为多个变量，让同样多的线程去竞争多个资源,是不是就解决了性能问题?使用AtomicLong 时
阅读更多2024-09-30
2024前端技术发展概况
好的错误处理和调试工具，提升开发效率和质量。可访问性和性能优化变得越来越重要，开发者需注重网站加载速度、响应性以及在不同设备和浏览器上的兼容性，采用懒加载、缓存优化等技术，并关注可访问性标准。
阅读更多2024-09-30
【数据库】在 Java 中使用 MongoDB 进行数据聚合
MongoDB 的聚合框架允许对数据进行复杂的处理和计算，这是分析和报告数据的强大工具。本文将介绍如何在 Java 中使用 MongoDB 进行数据聚合。
阅读更多2024-09-30
普通二叉搜索树的模拟实现【C++】
二叉搜索树又称二叉排序树，是具有以下性质的二叉树:若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树。
阅读更多2024-09-30