这里是只讲干货不讲废话的炽念，这个系列的文章是为了我自己以后复习数据结构而写，所以可能会用一种我自己能够听懂的方式来描述，不会像书本上那么枯燥和无聊，且全系列的代码均是可运行的代码，关键地方会给出注释^_^
全文近8000字
版本：C++17
编译器：Clion 2023.3.24
暂时只给出代码，不会涉及到基础知识的讲解
1.线性表的定义
//定义顺序表的表头结构
typedef struct {
Element* data; // 指向顺序表的数据区域
int len; // 该区域能够访问的边界条件，目前内容器存储数据的数量
int cap; // 该区域最大容量，超过这个容量就需要扩容
}SeqList;
// len 始终指向待插入位置
2.线性表的实现函数
2.1.表的创建以及删除
// 表的创建以及删除
SeqList *createSeqList(int n); // 创造一个表并初始化
void releaseSeqList(SeqList *seqList); // 释放掉表头以及表内的数据2.2.扩容函数
// 辅助函数
int enLargerSeq(SeqList *seqList); // 扩容函数2.3.向表中插入元素
// 三种插入方式
int pushBackSeq(SeqList *seqList, Element val); // 往尾部插入一个元素
int headInsertSeq(SeqList *seqList, Element val); // 往头部插入一个元素
int insertSeq(SeqList *seqList, int pos, Element val); // 按指定值来插入元素2.4.表的展示以及查找
// 展示以及查找
void showSeqList(SeqList *seqList); // 遍历并显示数据
int findSeq(SeqList *seqList, Element val); // 按值查找2.5.删除表中的元素
// 三种方式删除
int deleteSpeSeq(SeqList *seqList, Element val); // 删除特定值的元素
int deleteHeadSeq(SeqList *seqList); // 删除首元素
int deleteTailSeq(SeqList *seqList); // 删除尾元素
3.实现函数的代码
3.1.createSeqList函数的实现
函数定义：
SeqList *createSeqList(int n); // 创造一个表并初始化函数功能：
该函数用于创建一个长度为n的顺序表，并返回指向该顺序表的指针实现思路：
a.申请表头空间
b.申请表内元素的空间
c.初始化 len(length 长度) 和 cap(capacity 容量)
d.对申请的空间进行检查，如果申请空间失败，则需要返回NULL具体实现代码：
SeqList *createSeqList(int n) {
SeqList *seqList;
seqList = (SeqList *)malloc(sizeof(SeqList)); //申请表头
if (seqList == NULL){
printf("Malloc seqlist failed\n");
return NULL;
}
seqList->data = (Element *) malloc(sizeof(Element) * n); //申请空间
if (seqList->data == NULL){
printf("Malloc data failed");
return NULL;
}
seqList->len = 0;
seqList->cap = n;
return seqList;
}测试代码：
int main() {
SeqList *list = createSeqList(10);
if (list == NULL) {
printf("创建顺序表失败\n");
return 1;
}
printf("顺序表创建成功\n");
free(list->data);
free(list);
return 0;
}测试结果：
3.2 releaseSeqList函数的实现
函数定义：
void releaseSeqList(SeqList *seqList); // 释放掉表头以及表内的数据函数功能：
该函数用于释放一个顺序表所占用的内存空间，防止内存泄漏实现思路：
a.先判断表头再判断数据域是否为空
b.如果数据域不为空，则释放掉表内的数据域空间
c.释放掉表头空间
具体实现代码：
void releaseSeqList(SeqList *seqList) {
if (seqList){
if (seqList->data){
free(seqList->data);
}
free(seqList);
printf("Release success!\n");
}
}测试代码：
int main() {
SeqList *list = createSeqList(10);
if (list == NULL) {
printf("创建顺序表失败\n");
return 1;
}
printf("顺序表创建成功\n");
releaseSeqList(list); // 释放顺序表
return 0;
}测试结果：
3.3 enLargerSeq 函数的实现
函数定义：
int enLargerSeq(SeqList *seqList); // 扩容函数函数功能：
该函数用于对顺序表进行扩容，将顺序表的大小扩展为原来的两倍实现思路：
a.先申请一个新空间 tmp，新空间的大小为原来空间大小(seqList->len / seqList->cap)的两倍
b.将原来空间的值通过 for 循环赋值给新空间
c.释放掉原来表头指向的空间 seqList->data
d.将表头的 seqList->data 指向新申请的空间 tmp
e.将 seqList->cap 大小变为原来的两倍具体实现代码：
int enLargerSeq(SeqList *seqList) {
Element *tmp = (Element *) malloc(sizeof (Element) * 2 * seqList->cap);
if (!tmp){
printf("Enlarger element failed!\n");
return -1;
}
for (int i = 0; i < seqList->len; i++){
tmp[i] = seqList->data[i];
}
free(seqList->data); // 这两句是否有先后？
seqList->data = tmp; // 有先后，如果调换顺序就会先指向新的内存空间，然后再释放老的内存空间，此时老的内存空间已经找不到了，会发生内存泄露
seqList->cap *= 2;
printf("Enlarge success!\n");
return 0;
}测试代码：
int main(){
SeqList *list = createSeqList(5);
for (int i = 0; i < 5; i++){
pushBackSeq(list, i);
}
pushBackSeq(list,666);
showSeqList(list);
printf("%d", list->cap);
return 0;
}测试结果：
3.4 showSeqList && findSeq 函数的实现
函数定义：
void showSeqList(SeqList *seqList); // 遍历并显示数据
int findSeq(SeqList *seqList, Element val); // 按值查找函数功能：
1.showSeqList 函数
该函数用于遍历并显示顺序表中的所有数据2.findSeq 函数
该函数用于在顺序表中查找指定的值，并返回该值的索引。如果未找到，则返回 -1实现思路：
1.showSeqList 函数
a.首先判断传入的表是否为空
b.使用 for 循环遍历整个表并打印数据2.findSeq 函数
a.判断传染的表是否为空且表的长度是否合法(seqList->len > 0)
b.使用for循环遍历表，如果找到了val就直接返回该数的下标
c.如果没找到，打印提示信息，返回-1具体实现代码：
// showSeqList 函数
void showSeqList(SeqList *seqList) {
if (seqList == NULL || seqList->data == NULL){
printf("SeqList is null.Show error\n");
return;
}
for (int i = 0; i < seqList->len; i++){
printf("%d ", seqList->data[i]);
}
printf("\n");
}
// findSeq 函数
int findSeq(SeqList *seqList, Element val) {
if (!seqList || !seqList->data || seqList->len <= 0){
printf("SeqList is null!\n");
return -1;
}
for (int i = 0; i < seqList->len; i++){
if (seqList->data[i] == val){
return i;
}
}
printf("Find value error!\n");
return -1;
}测试代码：
int main(){
SeqList *list = createSeqList(5);
for (int i = 0; i < 5; i++){
pushBackSeq(list, i);
}
showSeqList(list);
int index1 = findSeq(list, 666);
int index2 = findSeq(list,0);
printf("%d\n", index1);
printf("%d\n", index2);
releaseSeqList(list);
return 0;
}测试结果：
3.4 pushBackSeq && headInsertSeq && insertSeq 函数的实现
函数定义：
int pushBackSeq(SeqList *seqList, Element val); // 往尾部插入一个元素
int headInsertSeq(SeqList *seqList, Element val); // 往头部插入一个元素
int insertSeq(SeqList *seqList, int pos, Element val); // 按指定位置来插入元素函数功能：
1.pushBackSeq 函数
在顺序表尾部插入一个元素2.headInsertSeq 函数
在顺序表头部插入一个元素3.insertSeq 函数
在顺序表指定位置插入一个元素实现思路：
1.pushBackSeq 函数
a.判断传入的链表以及数据域是否为空
b.判断当前元素是否到达空间上限，如果是则需要扩容
c.往 seqList->len 的位置放入元素
d.seqList->len++
2.headInsertSeq 函数
a.判断传入的链表以及数据域是否为空
b.判断当前元素是否到达空间上限，如果是则需要扩容
c.从第 1 个元素开始，依次往后移动元素
d.往下标为 0 的位置放入元素
e.seqList->len++
3.insertSeq 函数
a.判断传入的链表以及数据域是否为空
b.判断当前元素是否到达空间上限，如果是则需要扩容
c.从第 seqList->len-1 个元素开始，直到第 pos 个元素(包含)，从后往前移动元素
d.往下标为 pos 的位置放入元素
e.seqList->len++
具体实现代码：
1.pushBackSeq 函数
// pushBackSeq 函数
int pushBackSeq(SeqList *seqList, Element val) {
if (!seqList || !seqList->data){
printf("Seqlist is null");
return -1;
}
if (seqList->len >= seqList->cap){
printf("Insertion overflow. Consider enlarging the structure!\n");
if (enLargerSeq(seqList) == -1){
printf("Enlarge failed!\n");
return -1;
}
}
seqList->data[seqList->len] = val;
seqList->len++;
return 0;
}
2.headInsertSeq 函数
// headInsertSeq 函数
int headInsertSeq(SeqList *seqList, Element val) {
if (!seqList || !seqList->data){
printf("Seqlist is null");
return -1;
}
if (seqList->len >= seqList->cap){
printf("Insertion overflow. Consider enlarging the structure!\n");
if (enLargerSeq(seqList) == -1){
printf("Enlarge failed!\n");
return -1;
}
}
for (int i = seqList->len; i > 0; i--) { // 核心移动逻辑
seqList->data[i] = seqList->data[i-1];
}
seqList->data[0] = val;
seqList->len++;
return 0;
}3.insertSeq 函数
// insertSeq 函数
int insertSeq(SeqList *seqList, int pos, Element val) {
if (!seqList || !seqList->data){
printf("Seqlist is null");
return -1;
}
// 为什么是 > seqList->len，而不是 > seqList->cap?
// 顺序表是一种线性数据结构，它要求元素在内存中连续存储。这意味着元素之间不能有空隙，必须紧密排列
// 使用 len 而不是 cap 来确定插入位置，可以保证顺序表中的元素始终保持连续存储，这是顺序表的核心特征
if (pos < 0 || pos > seqList->len){
printf("Insert value out of bounds\n");
return -1;
}
if (seqList->len >= seqList->cap){
printf("Insertion overflow. Consider enlarging the structure!\n");
if (enLargerSeq(seqList) == -1){
printf("Enlarge failed!\n");
return -1;
}
}
for (int i = seqList->len-1; i >= pos; i--){ // 核心移动逻辑
seqList->data[i+1] = seqList->data[i];
}
seqList->data[pos] = val;
seqList->len++;
return 0;
}测试代码：
int main(){
SeqList *list = createSeqList(5);
for (int i = 0; i < 5; i++){
pushBackSeq(list, i);
}
showSeqList(list);
insertSeq(list, 5, 111); // 任意位置插入
showSeqList(list);
insertSeq(list, 0, 222); // 任意位置插入
showSeqList(list);
insertSeq(list, 999, 333); // 任意位置插入
showSeqList(list);
printf("\n");
headInsertSeq(list, 888); // 头插法
showSeqList(list);
printf("\n");
pushBackSeq(list, 666); // 尾插法
showSeqList(list);
releaseSeqList(list);
return 0;
}测试结果：
3.5 deleteSpeSeq && deleteHeadSeq && deleteTailSeq 函数的实现
函数定义：
int deleteSpeSeq(SeqList *seqList, Element val); // 删除特定值的元素
int deleteHeadSeq(SeqList *seqList); // 删除首元素
int deleteTailSeq(SeqList *seqList); // 删除尾元素函数功能：
1.deleteSpeSeq 函数
该函数用于在顺序表中删除指定值的元素2. deleteHeadSeq 函数
该函数用于删除顺序表中的首元素3.deleteTailSeq 函数
该函数用于删除顺序表中的尾元素实现思路：
1.deleteSpeSeq 函数
a.判断传入的表是否为空
b.调用 findSeq 函数，判断要查找的值是否在表中
c.如果不在表中，则返回错误标志
d.从 pos+1 的位置开始，从后往前覆盖元素
e.seqList->len--2. deleteHeadSeq 函数
a.判断传入的表是否为空
b.判断表内是否有元素
c.从第二个元素(索引为1)开始，从后往前进行覆盖
d.seqList->len--3.deleteTailSeq 函数
a.判断传入的表是否为空
b.判断表内是否有元素
d.seqList->len--具体实现代码：
1.deleteSpeSeq 函数
int deleteSpeSeq(SeqList *seqList, Element val) {
if (!seqList || !seqList->data){
printf("Seqlist is null. Delete failed!\n");
return -1;
}
int pos = findSeq(seqList, val);
if (pos == -1){
printf("Delete value error!\n");
return -1;
}
for (int i = pos + 1; i < seqList->len; i++){
seqList->data[i - 1] = seqList->data[i];
}
/*for (int i = pos; i < seqList->len; i++){ // 第二种写法可能会有溢出的风险
seqList->data[i] = seqList->data[i + 1];
}*/
seqList->len--;
return 0;
}2. deleteHeadSeq 函数
int deleteHeadSeq(SeqList *seqList) {
if (!seqList || !seqList->data){
printf("Seqlist is null. Delete failed!\n");
return -1;
}
if (seqList->len <= 0){
printf("Delete head value failed!");
return -1;
}
for (int i = 1; i < seqList->len; i++){
seqList->data[i-1] = seqList->data[i];
}
seqList->len--;
return 0;
}3.deleteTailSeq 函数
int deleteTailSeq(SeqList *seqList) {
if (!seqList || !seqList->data){
printf("Seqlist is null. Delete failed!\n");
return -1;
}
if (seqList->len <= 0){
printf("Delete tail value failed!");
return -1;
}
seqList->len--;
return 0;
}测试代码：
int main(){
SeqList *list = createSeqList(5);
for (int i = 0; i < 5; i++){
pushBackSeq(list, i);
}
deleteHeadSeq(list);
showSeqList(list);
deleteTailSeq(list);
showSeqList(list);
deleteSpeSeq(list,999);
showSeqList(list);
deleteSpeSeq(list,1);
showSeqList(list);
releaseSeqList(list);
return 0;
}测试结果：
扫一扫
1033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
